Pausa para café #92. 20 perguntas frequentes da entrevista sobre Java

Fonte: Dev.to Olá colegas desenvolvedores, compilei uma lista de perguntas básicas de entrevistas sobre Java que todo programador deve saber.

1. Como reverter uma string em Java sem usar métodos reverse()?

Resposta: Não existe um método Reverse() padrão em Java , embora o método Reverse() exista em várias bibliotecas, como StringBuffer ou StringBuilder . Portanto, a questão da reversão da matriz surge com frequência nas entrevistas. Abaixo está um algoritmo simples que pode ser usado para reverter uma matriz.

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. Escreva um trecho de código para implementar a sequência de Fibonacci usando recursão

Resposta: O trecho de código abaixo implementa a sequência de Fibonacci usando recursão. Essa pergunta também é muito comum em entrevistas 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. Como você remove espaços de uma string em Java?

Resposta: O método strip() é um método de string que remove todos os espaços iniciais e finais. Strip() usa o método Character.isWhitespace() internamente para verificar espaços em branco. Ele detecta espaços usando caracteres Unicodes e é a forma recomendada de remover espaços. Os métodos alternativos stripLeading() e stripTrailing() também podem ser usados . Eles ajudarão se você quiser remover apenas os espaços iniciais ou finais, respectivamente. O código abaixo é um exemplo de uso do método strip() .

String s = "  flexiple ";

s = s.strip();

System.out.println(s);

4. O que causa um cenário de impasse? Escreva código para criar impasse

Responda: Um cenário de deadlock ocorre quando dois threads requerem os mesmos bloqueios para serem executados. Esses cenários ocorrem quando ambos os threads adquiriram um bloqueio e estão aguardando para adquirir outro bloqueio. No entanto, como ambos os threads estão aguardando a execução do outro, eles bloqueiam um ao outro, causando um deadlock. Programas multithread sofrem de deadlocks porque a palavra-chave sincronizada é usada para tornar os métodos thread-safe. Isso significa que apenas um thread pode bloquear e usar um método sincronizado. Outros threads devem aguardar a conclusão do thread atual. O código abaixo cria dois threads que estão em conflito.

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. Escreva o código Java para imprimir a data em formato específico

Responda: A classe SimpleDateFormat ajuda a converter datas de um formato para outro. Este método também permite que os usuários usem um formato de string de data e alterem-no para o formato desejado. O código abaixo converte a data para o formato padrão: DD/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 de código para converter a data em MM/DD/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. Como classificar um HashMap por seus valores?

Resposta: HashMaps são usados ​​para implementar interfaces de mapas. Eles permitem que os usuários armazenem pares de valores-chave, mas as chaves devem ser exclusivas. HashMaps não são coleções ordenadas e classificá-los não faz sentido, mas como classificar hashmaps pode ser bastante complicado, eles são uma pergunta comum em entrevistas Java. O código abaixo mostra a implementação 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. O que o método forEach() faz? Explique com um exemplo

Resposta: forEach() é um método usado para iterar objetos em Java. Mas, diferentemente de outros loops, aqui o contador do loop não é declarado ou inicializado, mas sim a variável é passada como iterável. Portanto, forEach() geralmente é usado com arrays ou classes de coleção. Sintaxe:

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

Exemplo de uso 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. O que são interfaces funcionais e como são criadas?

Resposta: Uma interface contendo apenas um método abstrato é chamada de interface funcional. Posteriormente, as interfaces funcionais podem ter apenas uma função, porém podem conter vários métodos padrão. No Java 8, expressões lambda podem ser usadas para instanciar interfaces funcionais, tornando as coisas muito mais fáceis. Exemplos de interfaces funcionais: ActionListener , Comparable . Aqui está o código usado para definir a interface funcional.

@FunctionalInterface
interface Foo {
    void test();
}

9. Descreva a sobrecarga com um exemplo

Resposta: Sobrecarga é o processo de resolução de vários métodos com o mesmo nome, mas diferindo dependendo de suas assinaturas, tipo de dados ou número de parâmetros. A sobrecarga permite ao usuário reutilizar um único método em vez de criar e lembrar vários métodos. Resumindo, a sobrecarga está relacionada ao polimorfismo em tempo de compilação. Exemplo de código de sobrecarga de método:

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. Descreva a substituição com um exemplo

Resposta: A substituição é um recurso em Java que permite que subclasses ou classes filhas forneçam uma implementação separada para um método existente na classe pai. Quando um método em uma subclasse tem o mesmo nome, parâmetro e tipo de retorno que a classe pai, o método substitui o método na classe pai. E a versão do método que está sendo chamado determina qual método será executado. A substituição é uma maneira de obter polimorfismo em tempo de execução. Exemplo de código de substituição de método:

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. O que é pesquisa binária? Como isso é implementado?

Resposta: O algoritmo de pesquisa binária é usado para encontrar um valor em uma matriz classificada ou tipo de coleção. Este método de pesquisa é significativamente mais rápido que os métodos de pesquisa linear. A pesquisa binária divide o array em conjuntos menores e então aplica regras para verificar a chave de entrada. Estágios de implementação da pesquisa binária (binária):

• Classifique a matriz em ordem crescente.
• Encontre o valor médio da matriz e compare-o com a chave.
• Se a chave for igual à média, retorne verdadeiro.
• Se for falso, verifique se a chave é maior ou menor que o valor médio.
• A seguir, com base no resultado, marque a chave na metade superior ou inferior, respectivamente.
• Itere e compare cada valor com a chave.

Trecho de código implementando pesquisa binária:

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. Quais são os melhores métodos para evitar impasses em Java?

Responder:

• Aninhamento de bloqueios: a principal causa dos impasses é quando os bloqueios são passados ​​para vários threads. Evitar o bloqueio de vários threads caso já exista um thread com um bloco pode ajudar a evitar conflitos.
• Usando Thread.join() : Deadlocks também podem ocorrer quando um thread está aguardando um recurso de outro thread. Porém, nesses casos, Thread.join() pode ser usado com tempo máximo de execução.
• Usar bloqueio somente quando necessário: Pratique usar bloqueios apenas em elementos quando necessário. Bloqueios desnecessários são a principal causa de impasses.

13. Escreva código para implementar cache LRU em Java

Resposta: LRU significa Cache Menos Usado. O esquema de cache LRU é usado para remover o último cache usado. Esse processo ocorre quando o cache existente está cheio e a nova página referenciada não está no cache existente. O código abaixo mostra a implementação:

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. Como a matriz é girada dependendo da posição de K, por exemplo k = 2?

Resposta: O fragmento de código gira (retorna) o array dependendo da posição especificada. Embora pareça simples, ele testa sua compreensão de loops e arrays e, portanto, é uma pergunta comum em entrevistas 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. O que são filas em Java? Implemente-os usando arrays.

Resposta: As filas são estruturas lineares que demonstram a ordem das operações por ordem de chegada. Java fornece implementações mais simples para tipos de dados abstratos, como filas, pilhas e assim por diante. No entanto, implementá-los usando um array é uma questão que testa sua compreensão do conceito. Lembre-se de que a implementação do array de uma fila não é dinâmica.

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. O que é HeapSort? Escreva código para implementá-lo

Responda: HeapSort é um método de classificação baseado na estrutura de dados heap binários. Um heap binário é uma árvore binária na qual os elementos são armazenados de forma que os valores no nó pai sejam maiores (heap máximo) ou menores (heap mínimo) que os valores no nó filho. O código para implementar o HeapSort é assim:

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. O que é memorização?

Resposta: Memoização é uma abordagem que ajuda a resolver problemas causados ​​pela programação dinâmica. Este processo garante que um determinado método não será executado mais de uma vez para os mesmos dados de entrada. Os valores de retorno são armazenados em tabelas hash ou mapas hash e são reutilizados conforme necessário. O código abaixo é um exemplo de memorização na sequência 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. Escreva um trecho de código para implementar a classificação por bolhas

Resposta: O código abaixo é uma solução para classificação por bolha, que também é uma pergunta comum em entrevistas 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. O que são estruturas de dados experimentais em Java?

Resposta: Um Trie é uma estrutura de dados que armazena dados em uma estrutura de árvore ordenada usando chaves de armazenamento. A posição de um nó na árvore determina a chave associada ao nó, e os descendentes do nó compartilham um prefixo comum. Graças a essa estrutura, os testes oferecem melhor desempenho e também recuperam os dados com muito mais rapidez. No entanto, a única desvantagem do uso de madeira é que ela requer mais espaço de armazenamento.

20. Escreva um trecho de código para converter HashMap em ArrayList

Responda: O código abaixo é usado para converter HashMap em 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()); 
        } 
    } 
}