Sélection de questions d'entretien de code Java à haute fréquence

En tant que programmeurs Java, on nous posera certainement des questions sur le code Java lors de notre participation à des entretiens. Ces questions peuvent parfois être très élémentaires et sont souvent posées très fréquemment. Dans cet article, j'espère partager quelques questions d'entretien de codage Java haute fréquence courantes et précieuses que je pense.

1. Trouver les valeurs maximales et minimales dans un tableau

Ce problème est relativement basique. Habituellement, l'intervieweur peut vous demander d'écrire à la main un algorithme simple pour le résoudre.

Voici une méthode simple :

public static void findMinMax(int[] arr) {
    if (arr == null || arr.length == 0) {
        return;
    }
    int min = Integer.MAX_VALUE;
    int max = Integer.MIN_VALUE;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
        if (arr[i] > max) {
            max = arr[i];
        }
    }

    System.out.println("Minimum value: " + min);
    System.out.println("Maximum value: " + max);
}

2. Comment inverser une chaîne

Il s'agit d'une question d'entretien classique qui teste généralement si vous pouvez utiliser certaines API en Java pour implémenter des opérations de chaîne simples.

Voici une façon de procéder :

public static String reverseString(String str) {
    if (str == null || str.length() == 0) {
        return "";
    }

    char[] charArray = str.toCharArray();
    int i = 0;
    int j = str.length() - 1;

    while (i < j) {
        char temp = charArray[i];
        charArray[i] = charArray[j];
        charArray[j] = temp;
        i++;
        j--;
    }

    return new String(charArray);
}

3. Déterminez si une chaîne est une chaîne palindrome

C'est une autre question d'entretien de chaîne courante. Habituellement, l'intervieweur vous demandera d'écrire manuellement un algorithme pour déterminer si une chaîne est une chaîne palindrome.

Ce qui suit est une méthode d'implémentation :

public static boolean isPalindromeString(String str) {
    if (str == null || str.length() == 0) {
        return true;
    }

    int i = 0;
    int j = str.length() - 1;

    while (i < j) {
        if (str.charAt(i) != str.charAt(j)) {
            return false;
        }
        i++;
        j--;
    }

    return true;
}

4. Implémentation d'un modèle singleton

Il s'agit d'une question d'entretien Java très courante, qui vous oblige généralement à écrire à la main une implémentation du modèle singleton pour vous assurer qu'une seule instance peut être créé.

Ce qui suit est une méthode d'implémentation courante :

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造方法
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }

        return instance;
    }
}

Il s'agit d'une implémentation simple, mais elle n'est pas thread-safe. Dans une situation multithread, il peut arriver que plusieurs instances soient créées. Il convient de noter que afin de garantir la sécurité des threads, nous devons définir la méthode getInstance comme méthode synchronisée.

5. Comment implémenter une file d'attente de blocage

Il s'agit d'une question d'entretien Java relativement avancée. Vous devez généralement écrire manuellement une implémentation simple de file d'attente de blocage pour garantir que lorsque la file d'attente est pleine ou vide, les threads effectuant des opérations d'insertion et de suppression sur la file d'attente peuvent être bloqués en attendant que l'état soit réduit.

Ce qui suit est une implémentation simple de la file d'attente de blocage :

public class BlockingQueue<T> {
    private Queue<T> queue = new LinkedList<T>();
    private int capacity;

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public synchronized void put(T item) throws InterruptedException {
        while (queue.size() == capacity) {
            wait();
        }
        queue.add(item);
        notifyAll();
    }

    public synchronized T take() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();
        }
        T item = queue.remove();
        notifyAll();
        return item;
    }
}

L'implémentation ci-dessus utilise les méthodes wait() et notifyAll() en Java pour implémenter le blocage et l'éveil des threads. Lorsque la file d'attente est pleine ou vide, le thread qui insère ou supprime de la file d'attente sera bloqué en attendant que l'état de la file d'attente change.

Dans cet article, je partage quelques questions d'entretien Java courantes, qui sont généralement posées très fréquemment et constituent des points de connaissances qui méritent d'être maîtrisés en profondeur. Si vous vous préparez pour un entretien Java, j'espère que ces questions pourront vous aider !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!