Kaffeepause Nr. 92. 20 häufig gestellte Fragen zu Java-Interviews

Quelle: Dev.to Hallo liebe Entwickler, ich habe eine Liste mit grundlegenden Java-Interviewfragen zusammengestellt, die jeder Programmierer kennen sollte.

1. Wie kann ich eine Zeichenfolge in Java umkehren, ohne die Methoden reverse() zu verwenden?

Antwort: In Java gibt es keine Standardmethode reverse() , obwohl die Methode reverse() in mehreren Bibliotheken wie StringBuffer oder StringBuilder existiert . Daher kommt in Interviews sehr oft die Frage nach der Reihenumkehr auf. Nachfolgend finden Sie einen einfachen Algorithmus, der zum Umkehren eines Arrays verwendet werden kann.

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. Schreiben Sie einen Codeausschnitt, um die Fibonacci-Sequenz mithilfe der Rekursion zu implementieren

Antwort: Der folgende Codeausschnitt implementiert die Fibonacci-Folge mithilfe von Rekursion. Diese Frage kommt auch in Java-Interviews sehr häufig vor.

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. Wie entfernt man in Java Leerzeichen aus einer Zeichenfolge?

Antwort: Die Methode „strip()“ ist eine String-Methode, die alle führenden und nachfolgenden Leerzeichen entfernt. Strip() verwendet intern die Methode Character.isWhitespace() , um nach Leerzeichen zu suchen. Es erkennt Leerzeichen mithilfe von Unicode-Zeichen und ist die empfohlene Methode zum Entfernen von Leerzeichen. Alternativ können auch die Methoden StripLeading() und StripTrailing() verwendet werden . Sie sind hilfreich, wenn Sie nur führende bzw. nachfolgende Leerzeichen entfernen möchten. Der folgende Code ist ein Beispiel für die Verwendung der Methode „strip()“ .

String s = "  flexiple ";

s = s.strip();

System.out.println(s);

4. Was verursacht ein Deadlock-Szenario? Schreiben Sie Code, um einen Deadlock zu erzeugen

Antwort: Ein Deadlock-Szenario tritt auf, wenn zwei Threads zur Ausführung dieselben Sperren benötigen. Diese Szenarien treten auf, wenn beide Threads eine Sperre erworben haben und darauf warten, eine weitere Sperre zu erhalten. Da jedoch beide Threads auf die Ausführung des anderen warten, blockieren sie sich gegenseitig, was zu einem Deadlock führt. Multithread-Programme leiden unter Deadlocks, da das synchronisierte Schlüsselwort verwendet wird, um Methoden threadsicher zu machen. Dies bedeutet, dass nur ein Thread eine synchronisierte Methode blockieren und verwenden kann. Andere Threads müssen warten, bis der aktuelle Thread abgeschlossen ist. Der folgende Code erstellt zwei Threads, die blockiert sind.

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. Schreiben Sie Java-Code, um das Datum in einem bestimmten Format zu drucken

Antwort: Die Klasse SimpleDateFormat hilft beim Konvertieren von Datumsangaben von einem Format in ein anderes. Mit dieser Methode können Benutzer auch ein Datumszeichenfolgenformat verwenden und es in das gewünschte Format ändern. Der folgende Code konvertiert das Datum in das Standardformat: TT/MM/JJJJ

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));
}
}

Codeausschnitt zum Konvertieren des Datums in MM/TT/JJJJ:

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. Wie sortiere ich eine HashMap nach ihren Werten?

Antwort: HashMaps werden zur Implementierung von Kartenschnittstellen verwendet. Sie ermöglichen Benutzern das Speichern von Schlüssel-Wert-Paaren, die Schlüssel müssen jedoch eindeutig sein. HashMaps sind keine geordneten Sammlungen und es macht keinen Sinn, sie zu sortieren. Da das Sortieren von Hashmaps jedoch ziemlich schwierig sein kann, werden sie in Java-Interviews häufig gestellt. Der folgende Code zeigt die Implementierung von 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. Was macht die forEach()-Methode? Erklären Sie es anhand eines Beispiels

Antwort: forEach() ist eine Methode, die zum Durchlaufen von Objekten in Java verwendet wird. Aber im Gegensatz zu anderen Schleifen wird hier nicht der Schleifenzähler deklariert oder initialisiert, sondern die Variable wird als iterierbare Variable übergeben. Daher wird forEach() normalerweise mit Arrays oder Sammlungsklassen verwendet. Syntax:

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

Beispiel für die Verwendung von 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. Was sind funktionale Schnittstellen und wie werden sie erstellt?

Antwort: Eine Schnittstelle, die nur eine abstrakte Methode enthält, wird als funktionale Schnittstelle bezeichnet. Folglich können funktionale Schnittstellen nur eine Funktion haben, jedoch mehrere Standardmethoden enthalten. In Java 8 können Lambda-Ausdrücke zur Instanziierung funktionaler Schnittstellen verwendet werden, was die Arbeit erheblich vereinfacht. Beispiele für funktionale Schnittstellen: ActionListener , Comparable . Hier ist der Code, der zum Definieren der Funktionsschnittstelle verwendet wird.

@FunctionalInterface
interface Foo {
    void test();
}

9. Beschreiben Sie Überladung anhand eines Beispiels

Antwort: Beim Überladen werden mehrere Methoden mit demselben Namen aufgelöst, die sich jedoch je nach Signatur, Datentyp oder Anzahl der Parameter unterscheiden. Durch Überladen kann der Benutzer eine einzelne Methode wiederverwenden, anstatt mehrere Methoden zu erstellen und sich diese zu merken. Kurz gesagt, Überladung hängt mit dem Polymorphismus zur Kompilierungszeit zusammen. Beispielcode für eine Methodenüberladung:

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. Beschreiben Sie das Überschreiben anhand eines Beispiels

Antwort: Überschreiben ist eine Funktion in Java, die es Unterklassen oder untergeordneten Klassen ermöglicht, eine separate Implementierung für eine vorhandene Methode in der übergeordneten Klasse bereitzustellen. Wenn eine Methode in einer Unterklasse denselben Namen, Parameter und Rückgabetyp wie die übergeordnete Klasse hat, überschreibt die Methode die Methode in der übergeordneten Klasse. Und die Version der aufgerufenen Methode bestimmt, welche Methode ausgeführt wird. Überschreiben ist eine Möglichkeit, Polymorphismus zur Laufzeit zu erreichen. Beispiel für einen Methodenüberschreibungscode:

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. Was ist binäre Suche? Wie wird dies umgesetzt?

Antwort: Der binäre Suchalgorithmus wird verwendet, um einen Wert in einem sortierten Array oder Sammlungstyp zu finden. Diese Suchmethode ist deutlich schneller als lineare Suchmethoden. Die binäre Suche unterteilt das Array in kleinere Mengen und wendet dann Regeln an, um den Eingabeschlüssel zu überprüfen. Phasen der Implementierung der binären (binären) Suche:

• Sortieren Sie das Array in aufsteigender Reihenfolge.
• Ermitteln Sie den Durchschnittswert des Arrays und vergleichen Sie ihn mit dem Schlüssel.
• Wenn der Schlüssel dem Mittelwert entspricht, wird „true“ zurückgegeben.
• Wenn „false“, prüfen Sie, ob der Schlüssel größer oder kleiner als der Durchschnittswert ist.
• Überprüfen Sie anschließend anhand des Ergebnisses den Schlüssel in der oberen bzw. unteren Hälfte.
• Iterieren und vergleichen Sie jeden Wert mit dem Schlüssel.

Codeausschnitt zur Implementierung der binären Suche:

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. Was sind die besten Methoden, um Deadlocks in Java zu verhindern?

Antwort:

• Verschachtelte Sperren: Die Hauptursache für Deadlocks ist die Weitergabe von Sperren an mehrere Threads. Das Vermeiden des Blockierens mehrerer Threads für den Fall, dass bereits ein Thread mit einem Block vorhanden ist, kann dazu beitragen, Deadlocks zu vermeiden.
• Verwendung von Thread.join() : Deadlocks können auch auftreten, wenn ein Thread auf eine Ressource von einem anderen Thread wartet. In solchen Fällen kann jedoch Thread.join() mit maximaler Ausführungszeit verwendet werden.
• Sperren nur bei Bedarf verwenden: Üben Sie die Verwendung von Sperren für Elemente nur bei Bedarf. Unnötige Sperren sind die Hauptursache für Deadlocks.

13. Schreiben Sie Code, um LRU-Caching in Java zu implementieren

Antwort: LRU steht für Least Used Cache. Das LRU-Caching-Schema wird verwendet, um den zuletzt verwendeten Cache zu entfernen. Dieser Vorgang findet statt, wenn der vorhandene Cache voll ist und sich die neue Seite, auf die verwiesen wird, nicht im vorhandenen Cache befindet. Der folgende Code zeigt die Implementierung:

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. Wie wird das Array abhängig von der Position von K gedreht, zum Beispiel k = 2?

Antwort: Das Codefragment dreht das Array abhängig von der angegebenen Position (gibt es zurück). Obwohl es einfach erscheint, stellt es Ihr Verständnis von Schleifen und Arrays auf die Probe und ist daher eine häufige Frage in Java-Interviews.

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. Was sind Warteschlangen in Java? Implementieren Sie sie mithilfe von Arrays.

Antwort: Warteschlangen sind lineare Strukturen, die die Reihenfolge der Vorgänge nach dem Prinzip „Wer zuerst kommt, mahlt zuerst“ darstellen. Java bietet einfachere Implementierungen für abstrakte Datentypen wie Warteschlangen, Stapel usw. Allerdings ist die Implementierung mithilfe eines Arrays eine Frage, die Ihr Verständnis des Konzepts auf die Probe stellt. Denken Sie daran, dass die Array-Implementierung einer Warteschlange nicht dynamisch ist.

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. Was ist HeapSort? Schreiben Sie Code, um ihn zu implementieren

Antwort: HeapSort ist eine Sortiermethode, die auf der binären Heap-Datenstruktur basiert. Ein binärer Heap ist ein binärer Baum, in dem Elemente so gespeichert werden, dass die Werte im übergeordneten Knoten entweder größer (max-heap) oder kleiner (min-heap) sind als die Werte im untergeordneten Knoten. Der Code zur Implementierung von HeapSort sieht folgendermaßen aus:

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. Was ist Auswendiglernen?

Antwort: Memoization ist ein Ansatz, der dabei hilft, Probleme zu lösen, die durch dynamische Programmierung verursacht werden. Dieser Prozess stellt sicher, dass eine bestimmte Methode nicht mehr als einmal für dieselben Eingabedaten ausgeführt wird. Rückgabewerte werden in Hash-Tabellen oder Hash-Maps gespeichert und bei Bedarf wiederverwendet. Der folgende Code ist ein Beispiel für das Auswendiglernen in der Fibonacci-Folge.

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. Schreiben Sie einen Code, um die Blasensortierung zu implementieren

Antwort: Der folgende Code ist eine Lösung für die Blasensortierung, die auch in Java-Interviews häufig gestellt wird.

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. Was sind Trie-Datenstrukturen in Java?

Antwort: Ein Trie ist eine Datenstruktur, die Daten mithilfe von Speicherschlüsseln in einer geordneten Baumstruktur speichert. Die Position eines Knotens im Baum bestimmt den mit dem Knoten verknüpften Schlüssel, und die Nachkommen des Knotens haben ein gemeinsames Präfix. Dank dieser Struktur bieten Versuche eine bessere Leistung und rufen Daten auch viel schneller ab. Der einzige Nachteil bei der Verwendung von Holz besteht jedoch darin, dass mehr Lagerraum benötigt wird.

20. Schreiben Sie einen Codeausschnitt, um HashMap in ArrayList zu konvertieren

Antwort: Der folgende Code wird verwendet, um HashMap in ArrayList zu konvertieren .

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());
        }
    }
}