Pausa caffè #92. 20 domande frequenti per l'intervista su Java

Fonte: Dev.to Ciao colleghi sviluppatori, ho compilato un elenco di domande di base per un'intervista Java che ogni programmatore dovrebbe conoscere.

1. Come invertire una stringa in Java senza utilizzare i metodi reverse()?

Risposta: Non esiste un metodo reverse() standard in Java , sebbene il metodo reverse() esista in diverse librerie come StringBuffer o StringBuilder . Pertanto, la questione dell'inversione dell'array emerge molto spesso nelle interviste. Di seguito è riportato un semplice algoritmo che può essere utilizzato per invertire un array.

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. Scrivi uno snippet di codice per implementare la sequenza di Fibonacci utilizzando la ricorsione

Risposta: il frammento di codice seguente implementa la sequenza di Fibonacci utilizzando la ricorsione. Questa domanda è molto comune anche nelle interviste 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. Come si rimuovono gli spazi da una stringa in Java?

Risposta: Il metodo strip() è un metodo di stringa che rimuove tutti gli spazi iniziali e finali. Strip() utilizza internamente il metodo Character.isWhitespace() per verificare la presenza di spazi bianchi. Rileva gli spazi utilizzando i caratteri Unicodes ed è il modo consigliato per rimuovere gli spazi. Possono essere utilizzati anche i metodi alternativi stripLeading() e stripTrailing() . Ti aiuteranno se desideri rimuovere rispettivamente solo gli spazi iniziali o finali. Il codice seguente è un esempio dell'utilizzo del metodo strip() .

String s = "  flexiple ";

s = s.strip();

System.out.println(s);

4. Cosa causa uno scenario di stallo? Scrivi il codice per creare un deadlock

Risposta: uno scenario di deadlock si verifica quando due thread richiedono l'esecuzione degli stessi blocchi. Questi scenari si verificano quando entrambi i thread hanno acquisito un blocco e sono in attesa di acquisirne un altro. Tuttavia, poiché entrambi i thread attendono l'esecuzione dell'altro, si bloccano a vicenda, causando un deadlock. I programmi multithread soffrono di deadlock perché la parola chiave sincronizzata viene utilizzata per rendere i metodi thread-safe. Ciò significa che solo un thread può bloccare e utilizzare un metodo sincronizzato. Gli altri thread devono attendere il completamento del thread corrente. Il codice seguente crea due thread bloccati.

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. Scrivi il codice Java per stampare la data in un formato specifico

Risposta: la classe SimpleDateFormat aiuta a convertire le date da un formato all'altro. Questo metodo consente inoltre agli utenti di utilizzare un formato di stringa di data e di modificarlo nel formato desiderato. Il codice seguente converte la data nel formato standard: GG/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));
}
}

Snippet di codice per convertire la data in MM/GG/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. Come ordinare una HashMap in base ai suoi valori?

Risposta: gli HashMap vengono utilizzati per implementare le interfacce delle mappe. Consentono agli utenti di archiviare coppie chiave-valore, ma le chiavi devono essere univoche. Le HashMap non sono raccolte ordinate e ordinarle non ha senso, ma poiché l'ordinamento delle hashmap può essere piuttosto complicato, sono una domanda comune nelle interviste Java. Il codice seguente mostra l'implementazione di 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. Cosa fa il metodo forEach()? Spiegare con un esempio

Risposta: forEach() è un metodo utilizzato per scorrere gli oggetti in Java. Ma a differenza di altri cicli, qui il contatore del ciclo non viene dichiarato o inizializzato, ma piuttosto la variabile viene passata come iterabile. Pertanto, forEach() viene solitamente utilizzato con array o classi di raccolta. Sintassi:

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

Esempio di utilizzo di 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. Cosa sono le interfacce funzionali e come vengono create?

Risposta: Un'interfaccia contenente un solo metodo astratto è chiamata interfaccia funzionale. Di conseguenza, le interfacce funzionali possono avere solo una funzione, ma possono contenere più metodi predefiniti. In Java 8, le espressioni lambda possono essere utilizzate per creare un'istanza di interfacce funzionali, rendendo le cose molto più semplici. Esempi di interfacce funzionali: ActionListener , Comparable . Ecco il codice utilizzato per definire l'interfaccia funzionale.

@FunctionalInterface
interface Foo {
    void test();
}

9. Descrivi il sovraccarico con un esempio

Risposta: L'overloading è il processo di risoluzione di più metodi con lo stesso nome ma diversi a seconda della firma, del tipo di dati o del numero di parametri. Il sovraccarico consente all'utente di riutilizzare un singolo metodo anziché creare e ricordare più metodi. In breve, l'overloading è legato al polimorfismo in fase di compilazione. Codice di sovraccarico del metodo di esempio:

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. Descrivi l'overriding con un esempio

Risposta: L'overriding è una funzionalità di Java che consente alle sottoclassi o alle classi figlie di fornire un'implementazione separata per un metodo esistente nella classe genitore. Quando un metodo in una sottoclasse ha lo stesso nome, parametro e tipo restituito della classe genitore, il metodo sovrascrive il metodo nella classe genitore. E la versione del metodo chiamato determina quale metodo verrà eseguito. L'override è un modo per ottenere il polimorfismo in fase di esecuzione. Esempio di codice di override del metodo:

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. Cos'è la ricerca binaria? Come viene implementato?

Risposta: l'algoritmo di ricerca binaria viene utilizzato per trovare un valore in un array ordinato o in un tipo di raccolta. Questo metodo di ricerca è significativamente più veloce dei metodi di ricerca lineare. La ricerca binaria suddivide l'array in insiemi più piccoli e quindi applica le regole per controllare la chiave di input. Fasi dell'implementazione della ricerca binaria (binaria):

• Ordina l'array in ordine crescente.
• Trova il valore medio dell'array e confrontalo con la chiave.
• Se la chiave è uguale alla media, restituisce vero.
• Se falso, controlla se la chiave è maggiore o minore del valore medio.
• Successivamente, in base al risultato, controlla rispettivamente la chiave nella metà superiore o inferiore.
• Itera e confronta ogni valore con la chiave.

Snippet di codice che implementa la ricerca binaria:

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. Quali sono i metodi migliori per prevenire i deadlock in Java?

Risposta:

• Blocchi nidificati: la causa principale dei deadlock è quando i blocchi vengono trasmessi a più thread. Evitare di bloccare più thread nel caso in cui esista già un thread con un blocco può aiutare a prevenire i deadlock.
• Utilizzo di Thread.join() : i deadlock possono verificarsi anche quando un thread è in attesa di una risorsa da un altro thread. Tuttavia, in questi casi, Thread.join() può essere utilizzato con il tempo di esecuzione massimo.
• Utilizzo del blocco solo quando necessario: esercitati a utilizzare i blocchi solo sugli elementi quando necessario. I lock non necessari sono la causa principale dei deadlock.

13. Scrivere il codice per implementare la memorizzazione nella cache LRU in Java

Risposta: LRU sta per Least Used Cache. Lo schema di memorizzazione nella cache LRU viene utilizzato per rimuovere l'ultima cache utilizzata. Questo processo si verifica quando la cache esistente è piena e la nuova pagina a cui si fa riferimento non è nella cache esistente. Il codice seguente mostra l'implementazione:

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. Come viene ruotato l'array in base alla posizione di K, ad esempio k = 2?

Risposta: il frammento di codice ruota (restituisce) l'array in base alla posizione specificata. Sebbene sembri semplice, mette alla prova la tua comprensione di loop e array e quindi è una domanda comune nelle interviste 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. Cosa sono le code in Java? Implementali utilizzando gli array.

Risposta: Le code sono strutture lineari che dimostrano l'ordine delle operazioni in base all'ordine di arrivo. Java fornisce implementazioni più semplici per tipi di dati astratti come code, stack e così via. Tuttavia, implementarli utilizzando un array è una questione che mette alla prova la tua comprensione del concetto. Ricorda che l'implementazione dell'array di una coda non è dinamica.

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. Cos'è HeapSort? Scrivi il codice per implementarlo

Risposta: HeapSort è un metodo di ordinamento basato sulla struttura dei dati dell'heap binario. Un heap binario è un albero binario in cui gli elementi sono memorizzati in modo tale che i valori nel nodo genitore siano maggiori (max-heap) o minori (min-heap) rispetto ai valori nel nodo figlio. Il codice per implementare HeapSort è simile al seguente:

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. Cos'è la memorizzazione?

Risposta: La memorizzazione è un approccio che aiuta a risolvere i problemi causati dalla programmazione dinamica. Questo processo garantisce che un determinato metodo non verrà eseguito più di una volta per gli stessi dati di input. I valori restituiti vengono archiviati in tabelle hash o mappe hash e vengono riutilizzati secondo necessità. Il codice seguente è un esempio di memorizzazione nella sequenza di 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. Scrivi un pezzo di codice per implementare il bubble sorting

Risposta: il codice seguente è una soluzione per il bubble sort, che è anche una domanda comune nelle interviste 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. Cosa sono le strutture dati trie in Java?

Risposta: Un Trie è una struttura dati che memorizza i dati in una struttura ad albero ordinata utilizzando chiavi di archiviazione. La posizione di un nodo nell'albero determina la chiave associata al nodo e i discendenti del nodo condividono un prefisso comune. Grazie a questa struttura, i tentativi offrono prestazioni migliori e inoltre recuperano i dati molto più velocemente. Tuttavia, l’unico svantaggio dell’utilizzo del legno è che richiede più spazio di stoccaggio.

20. Scrivi uno snippet di codice per convertire HashMap in ArrayList

Risposta: il codice seguente viene utilizzato per convertire HashMap in 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());
        }
    }
}