Pause café #92. 20 questions d'entretien Java fréquemment posées

Source : Dev.to Bonjour chers développeurs, j'ai compilé une liste de questions d'entretien Java de base que tout codeur devrait connaître.

1. Comment inverser une chaîne en Java sans utiliser les méthodes reverse() ?

Réponse : Il n’existe pas de méthode reverse() standard en Java , bien que la méthode reverse() existe dans plusieurs bibliothèques telles que StringBuffer ou StringBuilder . La question de l’inversion des tableaux revient donc très souvent dans les entretiens. Vous trouverez ci-dessous un algorithme simple qui peut être utilisé pour inverser un tableau.

public class StringReverse {

    public static void main(String[] args) {

        String str = "Flexiple";
        System.out.println(reverse(str));
    }

    public static String reverse(String in) {
        if (in == null)
            throw new IllegalArgumentException("Null is not valid");

        StringBuilder out = new StringBuilder();

        char[] chars = in.toCharArray();

        for (int i = chars.length - 1; i >= 0; i--)
            out.append(chars[i]);

        return out.toString();
    }
}

2. Écrivez un extrait de code pour implémenter la séquence de Fibonacci en utilisant la récursivité

Réponse : L'extrait de code ci-dessous implémente la séquence de Fibonacci en utilisant la récursion. Cette question est également très courante dans les entretiens Java.

public class FibonacciNumbers {
    public static int fibonacci(int n) {
        if (n <= 1)
            return n;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }


    public static void main(String args[]) {
        int n = 10;
        System.out.println(fibonacci(n));
    }
}

3. Comment supprimer les espaces d’une chaîne en Java ?

Réponse : La méthode strip() est une méthode de chaîne qui supprime tous les espaces de début et de fin. Strip() utilise la méthode Character.isWhitespace() en interne pour vérifier les espaces. Il détecte les espaces à l'aide de caractères Unicodes et constitue la méthode recommandée pour supprimer les espaces. Les méthodes alternatives stripLeading() et stripTrailing() peuvent également être utilisées . Ils vous aideront si vous souhaitez supprimer respectivement uniquement les espaces de début ou de fin. Le code ci-dessous est un exemple d'utilisation de la méthode strip() .

String s = "  flexiple ";

s = s.strip();

System.out.println(s);

4. Quelles sont les causes d’un scénario de blocage ? Écrire du code pour créer une impasse

Réponse : Un scénario de blocage se produit lorsque deux threads nécessitent les mêmes verrous pour s'exécuter. Ces scénarios se produisent lorsque les deux threads ont acquis un verrou et attendent d’en acquérir un autre. Cependant, comme les deux threads attendent que l'autre s'exécute, ils se bloquent mutuellement, provoquant un blocage. Les programmes multithread souffrent de blocages car le mot-clé synchronisé est utilisé pour rendre les méthodes thread-safe. Cela signifie qu'un seul thread peut bloquer et utiliser une méthode synchronisée. Les autres threads doivent attendre que le thread en cours se termine. Le code ci-dessous crée deux threads bloqués.

class Util
{
    static void sleep(long millis)
    {
        try
        {
            Thread.sleep(millis);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}
class Shared
{
    synchronized void test1(Shared s2)
    {
        System.out.println("test1-begin");
        Util.sleep(1000);

        s2.test2();
        System.out.println("test1-end");
    }

    synchronized void test2()
    {
        System.out.println("test2-begin");
        Util.sleep(1000);

        System.out.println("test2-end");
    }
}

class Thread1 extends Thread
{
    private Shared s1;
    private Shared s2;

    public Thread1(Shared s1, Shared s2)
    {
        this.s1 = s1;
        this.s2 = s2;
    }

    @Override
    public void run()
    {
        s1.test1(s2);
    }
}

class Thread2 extends Thread
{
    private Shared s1;
    private Shared s2;

    public Thread2(Shared s1, Shared s2)
    {
        this.s1 = s1;
        this.s2 = s2;
    }

    @Override
    public void run()
    {
        s2.test2(s1);
    }
}

public class Deadlock
{
    public static void main(String[] args)
    {
        Shared s1 = new Shared();

        Shared s2 = new Shared();

        Thread1 t1 = new Thread1(s1, s2);
        t1.start();

        Thread2 t2 = new Thread2(s1, s2);
        t2.start();

        Util.sleep(2000);
    }
}

5. Écrivez du code Java pour imprimer la date dans un format spécifique

Réponse : La classe SimpleDateFormat permet de convertir les dates d'un format à un autre. Cette méthode permet également aux utilisateurs d'utiliser un format de chaîne de date et de le modifier au format souhaité. Le code ci-dessous convertit la date au format standard : JJ/MM/AAAA

import java.text.SimpleDateFormat;
import java.util.Date;
public class CurrentDateTimeExample2 {
public static void main(String[] args) {
    SimpleDateFormat formatter = new SimpleDateFormat("DD/MM/YYYY HH:mm:ss");
    Date date = new Date();
    System.out.println(formatter.format(date));
}
}

Extrait de code pour convertir la date en MM/JJ/AAAA :

import java.text.SimpleDateFormat;
import java.util.Date;
public class CurrentDateTimeExample2 {
public static void main(String[] args) {
    SimpleDateFormat formatter = new SimpleDateFormat("MM/DD/YYYY HH:mm:ss");
    Date date = new Date();
    System.out.println(formatter.format(date));
}
}

6. Comment trier un HashMap par ses valeurs ?

Réponse : Les HashMaps sont utilisés pour implémenter des interfaces cartographiques. Ils permettent aux utilisateurs de stocker des paires clé-valeur, mais les clés doivent être uniques. Les HashMaps ne sont pas des collections ordonnées et les trier n'a pas de sens, mais comme le tri des hashmaps peut être assez délicat, c'est une question courante dans les entretiens Java. Le code ci-dessous montre l'implémentation de HashMaps .

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class SortHashMap {

    public static void main(String[] args) {
        Map scores = new HashMap<>();

        scores.put("John", 6);
        scores.put("Carol", 8);
        scores.put("Martin", 9);
        scores.put("Mona", 7);
        scores.put("Eric", 5);

        System.out.println(scores);

        scores = sortByValue(scores);

        System.out.println(scores);

    }

    private static Map sortByValue(Map scores) {
        Map sorted = new LinkedHashMap<>();

        Set> entrySet = scores.entrySet();
        System.out.println(entrySet);

        List> entryList = new ArrayList<>(entrySet);
        System.out.println(entryList);

        entryList.sort((x, y) -> x.getValue().compareTo(y.getValue()));
        System.out.println(entryList);

        for (Entry e : entryList)
            sorted.put(e.getKey(), e.getValue());

        return sorted;
    }

}

7. Que fait la méthode forEach() ? Expliquez avec un exemple

Réponse : forEach() est une méthode utilisée pour parcourir des objets en Java. Mais contrairement aux autres boucles, ici le compteur de boucle n'est pas déclaré ou initialisé, mais plutôt la variable est passée comme itérable. Par conséquent, forEach() est généralement utilisé avec des tableaux ou des classes de collection. Syntaxe:

for (type var : array)
{
    statements using var;
}

Exemple d'utilisation de forEach() :

class ExampleForEach
{
    public static void main(String[] arg)
    {
        {
            int[] scores = { 10, 13, 9, 11, 11};

            int highest_score = maximum(scores);
            System.out.println(highest_scores);
        }
    }
    public static int maximum(int[] numbers)
    {
        int max = numbers[0];

        // for each loop
        for (int n : numbers)
        {
            if (n > max)
            {
                max = n;
            }
        }
    return max;
    }
}

8. Que sont les interfaces fonctionnelles et comment sont-elles créées ?

Réponse : Une interface contenant une seule méthode abstraite est appelée une interface fonctionnelle. Par la suite, les interfaces fonctionnelles ne peuvent avoir qu’une seule fonction, cependant elles peuvent contenir plusieurs méthodes par défaut. Dans Java 8, les expressions lambda peuvent être utilisées pour instancier des interfaces fonctionnelles, ce qui rend les choses beaucoup plus faciles. Exemples d'interfaces fonctionnelles : ActionListener , Comparable . Voici le code utilisé pour définir l'interface fonctionnelle.

@FunctionalInterface
interface Foo {
    void test();
}

9. Décrivez la surcharge avec un exemple

Réponse : La surcharge est le processus de résolution de plusieurs méthodes portant le même nom mais différant en fonction de leurs signatures, du type de données ou du nombre de paramètres. La surcharge permet à l'utilisateur de réutiliser une seule méthode plutôt que de créer et de mémoriser plusieurs méthodes. En bref, la surcharge est liée au polymorphisme au moment de la compilation. Exemple de code de surcharge de méthode :

public class Sum {

    public int sum(int x, int y)
    {
        return (x + y);
    }

    public int sum(int x, int y, int z)
    {
        return (x + y + z);
    }

    public double sum(double x, double y)
    {
        return (x + y);
    }

    public static void main(String args[])
    {
        Sum s = new Sum();
        System.out.println(s.sum(10, 20));
        System.out.println(s.sum(10, 20, 30));
        System.out.println(s.sum(10.5, 20.5));
    }
}

10. Décrire le remplacement avec un exemple

Réponse : Le remplacement est une fonctionnalité de Java qui permet aux sous-classes ou aux classes enfants de fournir une implémentation distincte pour une méthode existante dans la classe parent. Lorsqu'une méthode d'une sous-classe a le même nom, le même paramètre et le même type de retour que la classe parent, la méthode remplace la méthode de la classe parent. Et la version de la méthode appelée détermine quelle méthode sera exécutée. La substitution est un moyen d'obtenir un polymorphisme au moment de l'exécution. Exemple de code de remplacement de méthode :

class Parent {
    void show()
    {
        System.out.println("Parent's show()");
    }
}

class Child extends Parent {
    @Override
    void show()
    {
        System.out.println("Child's show()");
    }
}

class Main {
    public static void main(String[] args)
    {
        Parent obj1 = new Parent();
        obj1.show();

        Parent obj2 = new Child();
        obj2.show();
    }
}

11. Qu'est-ce que la recherche binaire ? Comment cela est-il mis en œuvre ?

Réponse : L'algorithme de recherche binaire est utilisé pour trouver une valeur dans un tableau trié ou un type de collection. Cette méthode de recherche est nettement plus rapide que les méthodes de recherche linéaire. La recherche binaire divise le tableau en ensembles plus petits, puis applique des règles pour vérifier la clé d'entrée. Étapes de mise en œuvre de la recherche binaire (binaire) :

• Triez le tableau par ordre croissant.
• Trouvez la valeur moyenne du tableau et comparez-la avec la clé.
• Si la clé est égale à la moyenne, renvoie vrai.
• Si faux, vérifiez si la clé est supérieure ou inférieure à la valeur moyenne.
• Ensuite, en fonction du résultat, vérifiez la clé dans la moitié supérieure ou inférieure, respectivement.
• Itérez et comparez chaque valeur avec la clé.

Extrait de code implémentant la recherche binaire :

import java.util.Scanner;

public class BinarySearch {

    public static void main(String[] args) {

        Scanner commandReader = new Scanner(System.in);
        System.out.println("Enter total number of elements : ");
        int length = commandReader.nextInt();
        int[] input = new int[length];

        System.out.printf("Enter %d integers %n", length);
        for (int i = 0; i < length; i++) {
            input[i] = commandReader.nextInt();
        }

        System.out.println("Please enter number to be searched in array
                                    (sorted order)");
        int key = commandReader.nextInt();

        int index = performBinarySearch(input, key);

        if (index == -1) {
            System.out.printf("Sorry, %d is not found in array %n", key);
        } else {
            System.out.printf("%d is found in array at index %d %n", key,
                                                         index);
        }

        commandReader.close();

    }


    public static int performBinarySearch(int[] input, int number) {
        int low = 0;
        int high = input.length - 1;

        while (high >= low) {
            int middle = (low + high) / 2;
            if (input[middle] == number) {
                return middle;
            } else if (input[middle] < number) {
                low = middle + 1;
            } else if (input[middle] > number) {
                high = middle - 1;
            }
        }
        return -1;
    }

}

12. Quelles sont les meilleures méthodes pour éviter les blocages en Java ?

Répondre:

• Verrous imbriqués : la principale cause des blocages est lorsque les verrous sont transmis à plusieurs threads. Éviter de bloquer plusieurs threads au cas où un thread avec un bloc existe déjà peut aider à éviter les blocages.
• Utilisation de Thread.join() : des blocages peuvent également se produire lorsqu'un thread attend une ressource d'un autre thread. Cependant, dans de tels cas, Thread.join() peut être utilisé avec un temps d'exécution maximal.
• Utiliser le verrouillage uniquement lorsque cela est nécessaire : Entraînez-vous à utiliser les verrous uniquement sur les éléments lorsque cela est nécessaire. Les verrous inutiles sont la principale cause des blocages.

13. Écrivez du code pour implémenter la mise en cache LRU en Java

Réponse : LRU signifie Cache le moins utilisé. Le schéma de mise en cache LRU est utilisé pour supprimer le dernier cache utilisé. Ce processus se produit lorsque le cache existant est plein et que la nouvelle page référencée ne se trouve pas dans le cache existant. Le code ci-dessous montre l'implémentation :

import java.util.Deque;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Iterator;

public class LRUCache {

    private Deque doublyQueue;

    private HashSet hashSet;

    private final int CACHE_SIZE;

    LRUCache(int capacity) {
        doublyQueue = new LinkedList<>();
        hashSet = new HashSet<>();
        CACHE_SIZE = capacity;
    }

    public void refer(int page) {
        if (!hashSet.contains(page)) {
            if (doublyQueue.size() == CACHE_SIZE) {
                int last = doublyQueue.removeLast();
                hashSet.remove(last);
            }
        }
        else {/* The found page may not be always the last element, even if it's an
            intermediate element that needs to be removed and added to the start
            of the Queue */
            doublyQueue.remove(page);
        }
        doublyQueue.push(page);
        hashSet.add(page);
    }

    public void display() {
        Iterator itr = doublyQueue.iterator();
        while (itr.hasNext()) {
            System.out.print(itr.next() + " ");
        }
    }

    public static void main(String[] args) {
        LRUCache cache = new LRUCache(4);
        cache.refer(1);
        cache.refer(2);
        cache.refer(3);
        cache.refer(1);
        cache.refer(4);
        cache.refer(5);
        cache.refer(2);
        cache.refer(2);
        cache.refer(1);
        cache.display();
    }
}

14. Comment le tableau tourne-t-il en fonction de la position de K, par exemple k = 2 ?

Réponse : Le fragment de code fait pivoter (renvoie) le tableau en fonction de la position spécifiée. Bien que cela semble simple, cela teste votre compréhension des boucles et des tableaux et constitue donc une question courante dans les entretiens Java.

public static int[] rotateBruteForce(int[] nums, int k) {
 for (int i = 0; i < k; i++) {
 for (int j = nums.length - 1; j > 0; j--) {
 // move each number by 1 place
 int temp = nums[j];
 nums[j] = nums[j - 1];
 nums[j - 1] = temp;
 }
 System.out.println("Array rotation after "+(i+1)+" step");
 printArray(nums);
 System.out.println();
 }
 return nums;
 }

15. Que sont les files d’attente en Java ? Implémentez-les à l’aide de tableaux.

Réponse : Les files d'attente sont des structures linéaires qui démontrent l'ordre des opérations selon le principe du premier arrivé, premier servi. Java fournit des implémentations plus simples pour les types de données abstraits tels que les files d'attente, les piles, etc. Cependant, les implémenter à l’aide d’un tableau est une question qui teste votre compréhension du concept. N'oubliez pas que l'implémentation matricielle d'une file d'attente n'est pas dynamique.

package org.arpit.java2blog;

public class QueueUsingArrayMain {

    private int capacity;
    int queueArr[];
    int front;
    int rear;
    int currentSize = 0;

    public QueueUsingArrayMain(int sizeOfQueue) {
        this.capacity = sizeOfQueue;
        front = 0;
        rear = -1;
        queueArr = new int[this.capacity];
    }

16. Qu'est-ce que HeapSort ? Écrire du code pour l'implémenter

Réponse : HeapSort est une méthode de tri basée sur la structure de données du tas binaire. Un tas binaire est un arbre binaire dans lequel les éléments sont stockés de telle manière que les valeurs du nœud parent soient soit supérieures (max-heap), soit inférieures (min-heap) aux valeurs du nœud enfant. Le code pour implémenter HeapSort ressemble à ceci :

public class HeapSort {
    public void sort(int arr[])
    {
        int n = arr.length;

        // Build heap (rearrange array)
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(arr, n, i);

        // One by one extract an element from heap
        for (int i = n - 1; i > 0; i--) {
            // Move current root to end
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            // call max heapify on the reduced heap
            heapify(arr, i, 0);
        }
    }

    // To heapify a subtree rooted with node i which is
    // an index in arr[]. n is size of heap
    void heapify(int arr[], int n, int i)
    {
        int largest = i; // Initialize largest as root
        int l = 2 * i + 1; // left = 2*i + 1
        int r = 2 * i + 2; // right = 2*i + 2

        // If left child is larger than root
        if (l < n && arr[l] > arr[largest])
            largest = l;

        // If right child is larger than largest so far
        if (r < n && arr[r] > arr[largest])
            largest = r;

        // If largest is not root
        if (largest != i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;

            // Recursively heapify the affected sub-tree
            heapify(arr, n, largest);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i = 0; i < n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver code
    public static void main(String args[])
    {
        int arr[] = { 12, 11, 13, 5, 6, 7 };
        int n = arr.length;

        HeapSort ob = new HeapSort();
        ob.sort(arr);

        System.out.println("Sorted array is");
        printArray(arr);
    }
}

17. Qu'est-ce que la mémisation ?

Réponse : La mémorisation est une approche qui permet de résoudre les problèmes causés par la programmation dynamique. Ce processus garantit qu'une méthode donnée ne sera pas exécutée plus d'une fois pour les mêmes données d'entrée. Les valeurs de retour sont stockées dans des tables de hachage ou des cartes de hachage et sont réutilisées si nécessaire. Le code ci-dessous est un exemple de mémorisation dans la séquence de Fibonacci.

import java.io.*;

class GFG
{

// Fibonacci Series
// using Recursion
static int fib(int n)
{

    // Base case
    if (n <= 1)
        return n;

    // recursive calls
    return fib(n - 1) +
        fib(n - 2);
}

// Driver Code
public static void main (String[] args)
{
    int n = 6;
    System.out.println(fib(n));
}
}

18. Écrivez un morceau de code pour implémenter le tri à bulles

Réponse : Le code ci-dessous est une solution pour le tri à bulles, qui est également une question courante dans les entretiens Java.

public class BubbleSortExample {
    static void bubbleSort(int[] arr) {
        int n = arr.length;
        int temp = 0;
         for(int i=0; i < n; i++){
                 for(int j=1; j < (n-i); j++){
                          if(arr[j-1] > arr[j]){
                                 //swap elements
                                 temp = arr[j-1];
                                 arr[j-1] = arr[j];
                                 arr[j] = temp;
                         }
                 }
         }
    }
    public static void main(String[] args) {
                int arr[] ={3,60,35,2,45,320,5};
                System.out.println("Array Before Bubble Sort");
                for(int i=0; i < arr.length; i++){
                        System.out.print(arr[i] + " ");
                }
                System.out.println();
                bubbleSort(arr);//sorting array elements using bubble sort
                System.out.println("Array After Bubble Sort");
                for(int i=0; i < arr.length; i++){
                        System.out.print(arr[i] + " ");
                }

        }
}

19. Que sont les structures de données trie en Java ?

Réponse : Un Trie est une structure de données qui stocke les données dans une structure arborescente ordonnée à l'aide de clés de stockage. La position d'un nœud dans l'arborescence détermine la clé associée au nœud, et les descendants du nœud partagent un préfixe commun. Grâce à cette structure, les essais offrent de meilleures performances et récupèrent également les données beaucoup plus rapidement. Cependant, le seul inconvénient de l’utilisation du bois est qu’il nécessite plus d’espace de stockage.

20. Écrivez un extrait de code pour convertir HashMap en ArrayList

Réponse : Le code ci-dessous est utilisé pour convertir HashMap en ArrayList .

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Java8MapToListExamples
{
    public static void main(String[] args)
    {
        //Creating a HashMap object

        HashMap studentPerformanceMap = new HashMap();

        //Adding elements to HashMap

        studentPerformanceMap.put("John Kevin", "Average");

        studentPerformanceMap.put("Rakesh Sharma", "Good");

        studentPerformanceMap.put("Prachi D", "Very Good");

        studentPerformanceMap.put("Ivan Jose", "Very Bad");

        studentPerformanceMap.put("Smith Jacob", "Very Good");

        studentPerformanceMap.put("Anjali N", "Bad");

        //Getting Set of keys

        Set keySet = studentPerformanceMap.keySet();

        //Creating an ArrayList of keys

        ArrayList listOfKeys = new ArrayList(keySet);

        System.out.println("ArrayList Of Keys :");

        for (String key : listOfKeys)
        {
            System.out.println(key);
        }

        System.out.println("--------------------------");

        //Getting Collection of values

        Collection values = studentPerformanceMap.values();

        //Creating an ArrayList of values

        ArrayList listOfValues = new ArrayList(values);

        System.out.println("ArrayList Of Values :");

        for (String value : listOfValues)
        {
            System.out.println(value);
        }

        System.out.println("--------------------------");

        //Getting the Set of entries

        Set> entrySet = studentPerformanceMap.entrySet();

        //Creating an ArrayList Of Entry objects

        ArrayList> listOfEntry = new ArrayList>(entrySet);

        System.out.println("ArrayList of Key-Values :");

        for (Entry entry : listOfEntry)
        {
            System.out.println(entry.getKey()+" : "+entry.getValue());
        }
    }
}