Pausa para el café #92. 20 preguntas frecuentes de la entrevista sobre Java

Fuente: Dev.to Hola compañeros desarrolladores, he compilado una lista de preguntas básicas de entrevistas sobre Java que todo programador debería conocer.

1. ¿Cómo invertir una cadena en Java sin utilizar métodos inversos ()?

Respuesta: No existe un método inverso() estándar en Java , aunque el método inverso() existe en varias bibliotecas como StringBuffer o StringBuilder . Por lo tanto, la cuestión de la inversión de matrices surge con mucha frecuencia en las entrevistas. A continuación se muestra un algoritmo simple que se puede utilizar para invertir una 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. Escriba un fragmento de código para implementar la secuencia de Fibonacci mediante recursividad.

Respuesta: El siguiente fragmento de código implementa la secuencia de Fibonacci mediante recursividad. Esta pregunta también es muy común en las entrevistas de 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. ¿Cómo se eliminan espacios de una cadena en Java?

Respuesta: El método strip() es un método de cadena que elimina todos los espacios iniciales y finales. Strip() utiliza el método Character.isWhitespace() internamente para comprobar los espacios en blanco. Detecta espacios utilizando caracteres Unicodes y es la forma recomendada de eliminar espacios. También se pueden utilizar métodos alternativos stripLeading() y stripTrailing() . Le ayudarán si desea eliminar sólo los espacios iniciales o finales, respectivamente. El siguiente código es un ejemplo del uso del método strip() .

String s = "  flexiple ";

s = s.strip();

System.out.println(s);

4. ¿Qué causa un escenario de punto muerto? Escribir código para crear un punto muerto

Respuesta: Se produce un escenario de punto muerto cuando dos subprocesos requieren la ejecución de los mismos bloqueos. Estos escenarios ocurren cuando ambos subprocesos han adquirido un bloqueo y están esperando adquirir otro bloqueo. Sin embargo, dado que ambos subprocesos están esperando que el otro se ejecute, se bloquean entre sí, provocando un punto muerto. Los programas multiproceso sufren bloqueos porque la palabra clave sincronizada se utiliza para hacer que los métodos sean seguros para los subprocesos. Esto significa que solo un hilo puede bloquear y utilizar un método sincronizado. Otros subprocesos deben esperar a que se complete el subproceso actual. El siguiente código crea dos subprocesos que están estancados.

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. Escriba código Java para imprimir la fecha en un formato específico

Responder: La clase SimpleDateFormat ayuda a convertir fechas de un formato a otro. Este método también permite a los usuarios utilizar un formato de cadena de fecha y cambiarlo al formato deseado. El siguiente código convierte la fecha al formato estándar: 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));
}
}

Fragmento de código para convertir la fecha a 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. ¿Cómo ordenar un HashMap por sus valores?

Respuesta: Los HashMaps se utilizan para implementar interfaces de mapas. Permiten a los usuarios almacenar pares clave-valor, pero las claves deben ser únicas. Los HashMaps no son colecciones ordenadas y ordenarlos no tiene sentido, pero dado que ordenarlos puede ser bastante complicado, son una pregunta común en las entrevistas sobre Java. El siguiente código muestra la implementación 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. ¿Qué hace el método forEach()? Explica con un ejemplo

Respuesta: forEach() es un método que se utiliza para iterar sobre objetos en Java. Pero a diferencia de otros bucles, aquí el contador del bucle no se declara ni se inicializa, sino que la variable se pasa como un iterable. Por lo tanto, forEach() generalmente se usa con matrices o clases de colección. Sintaxis:

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

Ejemplo 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. ¿Qué son las interfaces funcionales y cómo se crean?

Respuesta: Una interfaz que contiene solo un método abstracto se denomina interfaz funcional. Posteriormente, las interfaces funcionales solo pueden tener una función, sin embargo, pueden contener múltiples métodos predeterminados. En Java 8, las expresiones lambda se pueden utilizar para crear instancias de interfaces funcionales, lo que facilita mucho las cosas. Ejemplos de interfaces funcionales: ActionListener , Comparable . Aquí está el código utilizado para definir la interfaz funcional.

@FunctionalInterface
interface Foo {
    void test();
}

9. Describe la sobrecarga con un ejemplo.

Responder: La sobrecarga es el proceso de resolver múltiples métodos con el mismo nombre pero que difieren según sus firmas, tipo de datos o cantidad de parámetros. La sobrecarga permite al usuario reutilizar un único método en lugar de crear y recordar varios métodos. En resumen, la sobrecarga está relacionada con el polimorfismo en tiempo de compilación. Código de sobrecarga de método de ejemplo:

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. Describe la anulación con un ejemplo.

Respuesta: La anulación es una característica de Java que permite que las subclases o clases secundarias proporcionen una implementación separada para un método existente en la clase principal. Cuando un método en una subclase tiene el mismo nombre, parámetro y tipo de retorno que la clase principal, el método anula el método de la clase principal. Y la versión del método que se llama determina qué método se ejecutará. Anular es una forma de lograr polimorfismo en tiempo de ejecución. Ejemplo de código de anulación 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. ¿Qué es la búsqueda binaria? ¿Cómo se implementa esto?

Respuesta: El algoritmo de búsqueda binaria se utiliza para encontrar un valor en una matriz ordenada o un tipo de colección. Este método de búsqueda es significativamente más rápido que los métodos de búsqueda lineal. La búsqueda binaria divide la matriz en conjuntos más pequeños y luego aplica reglas para verificar la clave de entrada. Etapas de implementación de la búsqueda binaria (binaria):

• Ordene la matriz en orden ascendente.
• Encuentre el valor promedio de la matriz y compárelo con la clave.
• Si la clave es igual a la media, devuelve verdadero.
• Si es falso, verifique si la clave es mayor o menor que el valor promedio.
• A continuación, según el resultado, marque la clave en la mitad superior o inferior, respectivamente.
• Itere y compare cada valor con la clave.

Fragmento de código que implementa la búsqueda 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. ¿Cuáles son los mejores métodos para evitar interbloqueos en Java?

Respuesta:

• Bloqueos anidados: la causa principal de los interbloqueos es cuando los bloqueos se pasan a varios subprocesos. Evitar bloquear varios subprocesos en caso de que ya exista un subproceso con un bloqueo puede ayudar a evitar interbloqueos.
• Usando Thread.join() : Los interbloqueos también pueden ocurrir cuando un hilo está esperando un recurso de otro hilo. Sin embargo, en tales casos, Thread.join() se puede utilizar con el tiempo de ejecución máximo.
• Usar bloqueos solo cuando sea necesario: Practique usar bloqueos solo en elementos cuando sea necesario. Los bloqueos innecesarios son la principal causa de los interbloqueos.

13. Escriba código para implementar el almacenamiento en caché LRU en Java

Respuesta: LRU significa caché menos utilizada. El esquema de almacenamiento en caché LRU se utiliza para eliminar el último caché utilizado. Este proceso ocurre cuando el caché existente está lleno y la nueva página a la que se hace referencia no está en el caché existente. El siguiente código muestra la implementación:

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. ¿Cómo se gira la matriz dependiendo de la posición de K, por ejemplo k = 2?

Respuesta: El fragmento de código rota (devuelve) la matriz según la posición especificada. Aunque parece simple, pone a prueba su comprensión de los bucles y las matrices y, por lo tanto, es una pregunta común en las entrevistas sobre 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. ¿Qué son las colas en Java? Implementarlos usando matrices.

Respuesta: Las colas son estructuras lineales que demuestran el orden de las operaciones por orden de llegada. Java proporciona implementaciones más simples para tipos de datos abstractos como colas, pilas, etc. Sin embargo, implementarlos usando una matriz es una cuestión que pone a prueba su comprensión del concepto. Recuerde que la implementación de matriz de una cola no es 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. ¿Qué es HeapSort? Escribir código para implementarlo.

Responder: HeapSort es un método de clasificación basado en la estructura de datos del montón binario. Un montón binario es un árbol binario en el que los elementos se almacenan de tal manera que los valores en el nodo principal sean mayores (montón máximo) o menores (montón mínimo) que los valores en el nodo secundario. El código para implementar HeapSort tiene este aspecto:

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. ¿Qué es la memorización?

Respuesta: La memorización es un enfoque que ayuda a resolver problemas causados ​​por la programación dinámica. Este proceso garantiza que un método determinado no se ejecutará más de una vez para los mismos datos de entrada. Los valores de retorno se almacenan en tablas hash o mapas hash y se reutilizan según sea necesario. El siguiente código es un ejemplo de memorización en la secuencia 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. Escriba un fragmento de código para implementar la clasificación de burbujas.

Respuesta: El siguiente código es una solución para la clasificación de burbujas, que también es una pregunta común en las entrevistas sobre 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. ¿Qué son las estructuras de datos trie en Java?

Respuesta: Un Trie es una estructura de datos que almacena datos en una estructura de árbol ordenada utilizando claves de almacenamiento. La posición de un nodo en el árbol determina la clave asociada con el nodo y los descendientes del nodo comparten un prefijo común. Gracias a esta estructura, los intentos ofrecen un mejor rendimiento y además recuperan datos mucho más rápido. Sin embargo, el único inconveniente de utilizar madera es que requiere más espacio de almacenamiento.

20. Escriba un fragmento de código para convertir HashMap en ArrayList

Respuesta: El siguiente código se utiliza para convertir HashMap a 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());
        }
    }
}