コーヒーブレイク#92。Java 面接でよくある 20 の質問

出典: Dev.to 開発者の皆さん、こんにちは。すべてのプログラマーが知っておくべき基本的な Java 面接の質問のリストをまとめました。

1. reverse() メソッドを使用せずに Java で文字列を反転するにはどうすればよいですか?

回答: Java には標準のreverse()メソッドはありませんが、reverse()メソッドはStringBufferやStringBuilderなどのいくつかのライブラリに存在します。したがって、配列の反転に関する質問はインタビューで非常に頻繁に上がります。以下は、配列を反転するために使用できる簡単なアルゴリズムです。

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. 再帰を使用してフィボナッチ数列を実装するコード スニペットを作成します。

回答:以下のコード スニペットは、再帰を使用してフィボナッチ数列を実装しています。この質問は 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. Java で文字列からスペースを削除するにはどうすればよいですか?

回答: strip()メソッドは、先頭と末尾のスペースをすべて削除する文字列メソッドです。Strip() は内部でCharacter.isWhitespace()メソッドを使用して空白をチェックします。これは、Unicode 文字を使用してスペースを検出し、スペースを削除するための推奨される方法です。代替メソッドのstripLeading()およびstripTrailing()も使用できます。これらは、それぞれ先頭または末尾のスペースのみを削除する場合に役立ちます。以下のコードは、strip()メソッドの使用例です。

String s = "  flexiple ";

s = s.strip();

System.out.println(s);

4. デッドロック シナリオの原因は何ですか? デッドロックを引き起こすコードを書く

回答:デッドロック シナリオは、2 つのスレッドが実行するために同じロックを必要とする場合に発生します。これらのシナリオは、両方のスレッドが 1 つのロックを取得し、別のロックの取得を待機しているときに発生します。ただし、両方のスレッドが他方の実行を待機しているため、お互いにブロックし、デッドロックが発生します。マルチスレッド プログラムでは、メソッドをスレッド セーフにするために synchronized キーワードが使用されるため、デッドロックが発生します。これは、1 つのスレッドだけが同期メソッドをブロックして使用できることを意味します。他のスレッドは、現在のスレッドが完了するまで待機する必要があります。以下のコードは、デッドロックされた 2 つのスレッドを作成します。

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. 特定の形式で日付を印刷する Java コードを作成する

回答: SimpleDateFormatクラスは、日付をある形式から別の形式に変換するのに役立ちます。この方法では、ユーザーが日付文字列形式を使用し、それを目的の形式に変更することもできます。以下のコードは、日付を標準形式 (DD/MM/YYYY) に変換します。

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

日付を MM/DD/YYYY に変換するコード スニペット:

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. HashMap を値でソートするにはどうすればよいですか?

回答: HashMap はマップ インターフェイスを実装するために使用されます。ユーザーはキーと値のペアを保存できますが、キーは一意である必要があります。 HashMap は順序付けられたコレクションではないため、並べ替えることは意味がありませんが、ハッシュマップの並べ替えは非常に難しい場合があるため、Java の面接ではよくある質問です。以下のコードは、 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. forEach() メソッドは何をしますか? 例を挙げて説明する

回答: forEach() は、Java でオブジェクトを反復処理するために使用されるメソッドです。ただし、他のループとは異なり、ここではループ カウンターは宣言または初期化されず、変数が反復可能として渡されます。したがって、forEach()は通常、配列またはコレクション クラスとともに使用されます。構文：

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

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. 機能インターフェースとは何ですか?また、どのように作成されますか?

回答:抽象メソッドを 1 つだけ含むインターフェイスは、関数型インターフェイスと呼ばれます。その後、関数型インターフェイスには関数を 1 つだけ含めることができますが、複数のデフォルト メソッドを含めることができます。Java 8 では、ラムダ式を使用して関数インターフェイスをインスタンス化できるため、作業がはるかに簡単になります。関数インターフェイスの例: ActionListener、Comparable。関数インターフェイスを定義するために使用されるコードは次のとおりです。

@FunctionalInterface
interface Foo {
    void test();
}

9. 例を使ってオーバーロードを説明する

回答:オーバーロードとは、名前は同じだがシグネチャ、データ型、パラメーターの数に応じて異なる複数のメソッドを解決するプロセスです。オーバーロードを使用すると、ユーザーは複数のメソッドを作成して記憶するのではなく、単一のメソッドを再利用できます。つまり、オーバーロードはコンパイル時のポリモーフィズムに関連しています。メソッドのオーバーロード コードの例:

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. 例を使用してオーバーライドを説明する

回答:オーバーライドは、サブクラスまたは子クラスが親クラスの既存のメソッドに別の実装を提供できるようにする Java の機能です。サブクラスのメソッドが親クラスと同じ名前、パラメーター、戻り値の型を持つ場合、そのメソッドは親クラスのメソッドをオーバーライドします。そして、呼び出されるメソッドのバージョンによって、どのメソッドが実行されるかが決まります。オーバーライドは、実行時にポリモーフィズムを実現する方法です。メソッドオーバーライドのコード例:

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. 二分探索とは何ですか? これはどのように実装されますか?

回答:二分探索アルゴリズムは、並べ替えられた配列またはコレクション型内の値を見つけるために使用されます。この検索方法は、線形検索方法よりも大幅に高速です。二分検索では、配列を小さなセットに分割し、ルールを適用して入力キーをチェックします。 バイナリ (バイナリ) 検索の実装段階:

• 配列を昇順に並べ替えます。
• 配列の平均値を見つけてキーと比較します。
• キーが平均値と等しい場合は、true を返します。
• false の場合、キーが平均値より大きいか小さいかを確認します。
• 次に、その結​​果に基づいて、上半分または下半分のキーをそれぞれ確認します。
• 反復して各値をキーと比較します。

二分検索を実装するコード スニペット:

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. Java でのデッドロックを防ぐ最善の方法は何ですか?

答え：

• ネストされたロック: デッドロックの主な原因は、ロックが複数のスレッドに渡されることです。ブロックのあるスレッドがすでに存在する場合に複数のスレッドをブロックしないようにすると、デッドロックを防ぐことができます。
• Thread.join()の使用: デッドロックは、スレッドが別のスレッドからのリソースを待機しているときにも発生する可能性があります。ただし、そのような場合は、Thread.join() を使用すると実行時間を最大化できます。
• 必要な場合にのみロックを使用する: 必要な場合にのみ要素に対してロックを使用する練習をします。不必要なロックはデッドロックの主な原因です。

13. Java で LRU キャッシュを実装するコードを作成する

回答: LRU は最小使用キャッシュの略です。LRU キャッシュ スキームは、最後に使用されたキャッシュを削除するために使用されます。このプロセスは、既存のキャッシュがいっぱいで、参照されている新しいページが既存のキャッシュにない場合に発生します。以下のコードは実装を示しています。

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. K の位置 (たとえば k = 2) に応じて配列はどのように回転しますか?

回答:コード フラグメントは、指定された位置に応じて配列を回転 (返し) します。単純そうに見えますが、ループと配列の理解をテストするため、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. Java のキューとは何ですか? 配列を使用して実装します。

回答:キューは、先着順で操作の順序を示す線形構造です。Java は、キュー、スタックなどの抽象データ型のより単純な実装を提供します。ただし、配列を使用してそれらを実装することは、概念の理解をテストする問題です。キューの配列実装は動的ではないことに注意してください。

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. ヒープソートとは何ですか? それを実装するコードを書く

回答: HeapSort は、バイナリ ヒープ データ構造に基づく並べ替え方法です。バイナリ ヒープは、親ノードの値が子ノードの値より大きくなる (max-heap) か小さくなる (min-heap) ように要素が格納されるバイナリ ツリーです。HeapSort を実装するコードは次のようになります。

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. メモ化とは何ですか?

回答:メモ化は、動的プログラミングによって引き起こされる問題の解決に役立つアプローチです。このプロセスにより、特定のメソッドが同じ入力データに対して複数回実行されなくなります。戻り値はハッシュ テーブルまたはハッシュ マップに格納され、必要に応じて再利用されます。以下のコードは、フィボナッチ数列でのメモ化の例です。

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. バブルソートを実装するコードを書く

回答:以下のコードはバブル ソートのソリューションです。これは 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. Java の try データ構造とは何ですか?

回答:トライは、ストレージ キーを使用して順序付けされたツリー構造にデータを格納するデータ構造です。ツリー内のノードの位置によって、そのノードに関連付けられたキーが決まり、ノードの子孫は共通のプレフィックスを共有します。この構造のおかげで、試行のパフォーマンスが向上し、データの取得も高速になります。ただし、木材を使用する唯一の欠点は、より多くの保管スペースが必要になることです。

20. HashMap を ArrayList に変換するコード スニペットを作成します。

回答:以下のコードは、HashMap を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());
        }
    }
}