Przerwa kawowa #92. 20 najczęściej zadawanych pytań podczas rozmowy kwalifikacyjnej w języku Java

Źródło: Dev.to Witam kolegów programistów, przygotowałem listę podstawowych pytań do rozmowy kwalifikacyjnej w języku Java, które powinien znać każdy programista.

1. Jak odwrócić ciąg znaków w Javie bez użycia metod Reverse()?

Odpowiedź: W Javie nie ma standardowej metody Reverse() , chociaż metoda Reverse() istnieje w kilku bibliotekach, takich jak StringBuffer lub StringBuilder . Dlatego też kwestia odwrócenia tablicy pojawia się bardzo często w wywiadach. Poniżej znajduje się prosty algorytm, którego można użyć do odwrócenia tablicy.

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. Napisz fragment kodu implementujący ciąg Fibonacciego za pomocą rekurencji

Odpowiedź: Poniższy fragment kodu implementuje ciąg Fibonacciego przy użyciu rekurencji. To pytanie jest również bardzo częste podczas rozmów kwalifikacyjnych w języku 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. Jak usunąć spacje z łańcucha w Javie?

Odpowiedź: Metoda strip() to metoda łańcuchowa, która usuwa wszystkie początkowe i końcowe spacje. Strip() używa wewnętrznie metody Character.isWhitespace() do sprawdzania białych znaków. Wykrywa spacje przy użyciu znaków Unicode i jest zalecanym sposobem usuwania spacji. Można również zastosować alternatywne metody stripLeading() i stripTrailing() . Pomogą, jeśli chcesz usunąć odpowiednio tylko spacje początkowe i końcowe. Poniższy kod jest przykładem użycia metody strip() .

String s = "  flexiple ";

s = s.strip();

System.out.println(s);

4. Co powoduje scenariusz impasu? Napisz kod, aby utworzyć zakleszczenie

Odpowiedź: Scenariusz zakleszczenia ma miejsce, gdy dwa wątki wymagają wykonania tych samych blokad. Te scenariusze mają miejsce, gdy oba wątki uzyskały jedną blokadę i czekają na uzyskanie kolejnej. Ponieważ jednak oba wątki czekają na wykonanie drugiego, blokują się nawzajem, powodując zakleszczenie. W programach wielowątkowych występują zakleszczenia, ponieważ słowo kluczowe synchronized służy do zapewnienia bezpieczeństwa wątków metod. Oznacza to, że tylko jeden wątek może blokować i używać metody zsynchronizowanej. Inne wątki muszą czekać na zakończenie bieżącego wątku. Poniższy kod tworzy dwa wątki, które są zakleszczone.

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. Napisz kod Java, aby wydrukować datę w określonym formacie

Odpowiedź: Klasa SimpleDateFormat pomaga konwertować daty z jednego formatu na inny. Ta metoda umożliwia również użytkownikom użycie formatu ciągu daty i zmianę go na żądany format. Poniższy kod konwertuje datę do standardowego formatu: DD/MM/RRRR

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

Fragment kodu do konwersji daty na MM/DD/RRRR:

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. Jak posortować HashMap według wartości?

Odpowiedź: HashMaps służą do implementowania interfejsów map. Umożliwiają użytkownikom przechowywanie par klucz-wartość, ale klucze muszą być unikalne. HashMapy nie są uporządkowanymi kolekcjami i sortowanie ich nie ma sensu, ale ponieważ sortowanie hashmap może być dość trudne, są one częstym pytaniem w rozmowach kwalifikacyjnych w języku Java. Poniższy kod przedstawia implementację 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. Do czego służy metoda forEach()? Wyjaśnij na przykładzie

Odpowiedź: forEach() to metoda używana do iteracji po obiektach w Javie. Jednak w przeciwieństwie do innych pętli, tutaj licznik pętli nie jest deklarowany ani inicjowany, ale raczej zmienna jest przekazywana jako iterowalna. Dlatego forEach() jest zwykle używana z tablicami lub klasami kolekcji. Składnia:

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

Przykład użycia 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. Czym są interfejsy funkcjonalne i jak się je tworzy?

Odpowiedź: Interfejs zawierający tylko jedną metodę abstrakcyjną nazywany jest interfejsem funkcjonalnym. W związku z tym interfejsy funkcjonalne mogą mieć tylko jedną funkcję, mogą jednak zawierać wiele metod domyślnych. W Javie 8 można używać wyrażeń lambda do tworzenia instancji funkcjonalnych interfejsów, co znacznie ułatwia pracę. Przykłady interfejsów funkcjonalnych: ActionListener , Comparable . Oto kod użyty do zdefiniowania interfejsu funkcjonalnego.

@FunctionalInterface
interface Foo {
    void test();
}

9. Opisz przeciążenie na przykładzie

Odpowiedź: Przeciążanie to proces rozwiązywania wielu metod o tej samej nazwie, ale różniących się w zależności od ich podpisów, typu danych lub liczby parametrów. Przeciążanie pozwala użytkownikowi na ponowne użycie jednej metody zamiast tworzenia i zapamiętywania wielu metod. Krótko mówiąc, przeciążenie jest związane z polimorfizmem w czasie kompilacji. Przykładowy kod przeciążenia metody:

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. Opisz przesłonięcie na przykładzie

Odpowiedź: Zastępowanie to funkcja języka Java, która umożliwia podklasom lub klasom podrzędnym zapewnienie oddzielnej implementacji metody istniejącej w klasie nadrzędnej. Gdy metoda w podklasie ma tę samą nazwę, parametr i typ zwracany co klasa nadrzędna, metoda zastępuje metodę w klasie nadrzędnej. Wersja wywoływanej metody określa, która metoda zostanie wykonana. Zastępowanie to sposób na osiągnięcie polimorfizmu w czasie wykonywania. Przykładowy kod zastąpienia metody:

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. Co to jest wyszukiwanie binarne? Jak to jest realizowane?

Odpowiedź: Algorytm wyszukiwania binarnego służy do znajdowania wartości w posortowanej tablicy lub typie kolekcji. Ta metoda wyszukiwania jest znacznie szybsza niż metody wyszukiwania liniowego. Wyszukiwanie binarne dzieli tablicę na mniejsze zestawy, a następnie stosuje reguły w celu sprawdzenia klucza wejściowego. Etapy wdrażania wyszukiwania binarnego (binarnego):

• Posortuj tablicę w kolejności rosnącej.
• Znajdź średnią wartość tablicy i porównaj ją z kluczem.
• Jeśli klucz jest równy średniej, zwróć wartość true.
• Jeśli fałsz, sprawdź, czy klucz jest większy czy mniejszy od wartości średniej.
• Następnie na podstawie wyniku sprawdź klucz odpowiednio w górnej lub dolnej połowie.
• Iteruj i porównuj każdą wartość za pomocą klucza.

Fragment kodu implementujący wyszukiwanie binarne:

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. Jakie są najlepsze metody zapobiegania zakleszczeniom w Javie?

Odpowiedź:

• Zagnieżdżanie blokad: Główną przyczyną zakleszczeń jest przekazywanie blokad na wiele wątków. Unikanie blokowania wielu wątków w przypadku, gdy wątek z blokiem już istnieje, może pomóc w zapobieganiu zakleszczeniom.
• Używanie Thread.join() : Zakleszczenia mogą również wystąpić, gdy wątek czeka na zasób z innego wątku. Jednak w takich przypadkach można użyć Thread.join() z maksymalnym czasem wykonania.
• Używanie blokowania tylko wtedy, gdy jest to konieczne: ​​Przećwicz używanie zamków tylko na elementach, gdy jest to konieczne. Główną przyczyną zakleszczeń są niepotrzebne blokady.

13. Napisz kod implementujący buforowanie LRU w Javie

Odpowiedź: LRU oznacza najmniej używaną pamięć podręczną. Schemat buforowania LRU służy do usuwania ostatnio używanej pamięci podręcznej. Ten proces ma miejsce, gdy istniejąca pamięć podręczna jest pełna, a nowej strony, do której się odwołuje, nie ma w istniejącej pamięci podręcznej. Poniższy kod przedstawia implementację:

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. Jak obraca się tablica w zależności od położenia K, np. k = 2?

Odpowiedź: Fragment kodu obraca (zwraca) tablicę w zależności od określonej pozycji. Chociaż wydaje się to proste, sprawdza twoje zrozumienie pętli i tablic, dlatego jest częstym pytaniem podczas rozmów kwalifikacyjnych w języku 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. Czym są kolejki w Javie? Zaimplementuj je za pomocą tablic.

Odpowiedź: Kolejki to struktury liniowe, które pokazują kolejność operacji według kolejności zgłoszeń. Java zapewnia prostsze implementacje abstrakcyjnych typów danych, takich jak kolejki, stosy i tak dalej. Jednak wdrożenie ich za pomocą tablicy jest pytaniem sprawdzającym zrozumienie tej koncepcji. Pamiętaj, że implementacja tablicowa kolejki nie jest dynamiczna.

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. Co to jest HeapSort? Napisz kod, aby go zaimplementować

Odpowiedź: HeapSort to metoda sortowania oparta na binarnej strukturze danych. Kopiec binarny to drzewo binarne, w którym elementy są przechowywane w taki sposób, że wartości w węźle nadrzędnym są albo większe (max-heap), albo mniejsze (min-heap) niż wartości w węźle podrzędnym. Kod implementujący HeapSort wygląda następująco:

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. Co to jest zapamiętywanie?

Odpowiedź: Zapamiętywanie to podejście pomagające rozwiązywać problemy spowodowane programowaniem dynamicznym. Proces ten gwarantuje, że dana metoda nie zostanie wykonana więcej niż raz dla tych samych danych wejściowych. Zwracane wartości są przechowywane w tabelach skrótów lub mapach skrótów i są ponownie wykorzystywane w razie potrzeby. Poniższy kod jest przykładem zapamiętywania w ciągu Fibonacciego.

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. Napisz fragment kodu implementujący sortowanie bąbelkowe

Odpowiedź: Poniższy kod stanowi rozwiązanie sortowania bąbelkowego, które jest również częstym pytaniem podczas rozmów kwalifikacyjnych w języku 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. Czym są struktury danych Trie w Javie?

Odpowiedź: Trie to struktura danych, która przechowuje dane w uporządkowanej strukturze drzewa za pomocą kluczy pamięci. Pozycja węzła w drzewie określa klucz powiązany z węzłem, a potomkowie węzła mają wspólny przedrostek. Dzięki tej strukturze próby oferują lepszą wydajność, a także znacznie szybciej pobierają dane. Jednak jedyną wadą stosowania drewna jest to, że wymaga ono większej przestrzeni do przechowywania.

20. Napisz fragment kodu konwertujący HashMap na ArrayList

Odpowiedź: Poniższy kod służy do konwersji HashMap na 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());
        }
    }
}