País o región e idioma

    Elige tu país o región y tu idioma.

    Sugerido para ti

      Todos los países y regiones

        Elige tu personaje

        Aparece en la barra superior y en tu perfil. Puedes cambiarlo cuando quieras.

        Entrevista técnica Java: 10 preguntas

        Prepara tu entrevista técnica Java con 10 preguntas resueltas y dos ejercicios ejecutables sobre igualdad, colecciones y concurrencia, con criterios claros.

        Una persona practica con un equipo portátil en un espacio de trabajo tranquilo

        Una entrevista técnica Java puede combinar preguntas sobre ejecución, objetos, colecciones, excepciones y concurrencia con tareas de programación. Estas diez preguntas incluyen respuestas modelo, criterios de evaluación y dos ejercicios ejecutables con Java 17 para que puedas demostrar tus explicaciones, no solo repetir definiciones.

        Los fundamentos y la explicación técnica

        Los fundamentos permiten explicar cómo se ejecuta un programa y qué ocurre cuando un método recibe un objeto. Antes de responder, identifica si la pregunta trata de herramientas, referencias o cambios en el estado: mezclar esos conceptos suele producir respuestas aparentemente correctas, pero contradictorias.

        1. «¿Qué diferencia hay entre el JDK y la JVM, y cómo se ejecuta una aplicación Java?»
        
        Respuesta modelo: El JDK es el conjunto de herramientas de desarrollo; incluye el compilador javac y lo necesario para ejecutar programas. La JVM es la máquina virtual que ejecuta el bytecode, las instrucciones generadas al compilar. El código fuente se compila a archivos de clase; la JVM carga y ejecuta esas clases y puede compilar código a instrucciones nativas durante la ejecución.
        
        El entrevistador escucha: separación entre desarrollo y ejecución, significado de bytecode y ausencia de la afirmación de que todo se interpreta siempre.
        2. «¿Java pasa los objetos por valor o por referencia? ¿Qué ocurre al modificar un objeto recibido como argumento?»
        
        Respuesta modelo: Java siempre pasa los argumentos por valor. Para un objeto, se copia el valor de su referencia, que permite acceder al objeto. El método puede modificar el objeto compartido si este lo permite, pero reasignar el parámetro no cambia la referencia que conserva quien llamó al método.
        
        El entrevistador escucha: distinción entre modificar un objeto y reasignar una variable. Decir que los objetos se pasan por referencia no describe correctamente el mecanismo.

        Para explicar el paso por valor, describe por separado las dos variables y el objeto compartido. Esa separación también te ayudará a razonar sobre métodos que modifican listas recibidas como argumentos.

        La identidad y la igualdad comprobables

        La identidad indica si dos referencias apuntan al mismo objeto; la igualdad sigue el contrato definido por la clase. El primer ejercicio hace visible esa diferencia sin depender de que Java comparta ciertos textos literales.

        3. «¿Qué diferencia hay entre comparar dos objetos con == y con equals?»
        
        Respuesta modelo: Con referencias, == comprueba identidad. equals es un método cuyo comportamiento depende de la clase: Object compara identidad, mientras que String compara el contenido del texto. Con tipos primitivos, == compara valores.
        
        El entrevistador escucha: una explicación que nombre el tipo comparado y reconozca que equals no compara contenido automáticamente en cualquier clase.

        Para resolver la siguiente tarea, usa un JDK 17 con el comando java disponible en tu terminal. Guarda el programa como Igualdad.java y ejecuta desde esa carpeta el comando indicado al final del bloque; antes de hacerlo, predice las dos líneas de salida.

        // 4. «Escribe un programa que cree dos objetos String distintos
        // con el mismo texto y muestre su identidad y su igualdad».
        //
        // Respuesta modelo y especificación del ejercicio ficticio:
        // Entorno: JDK 17. Archivo: Igualdad.java.
        // Objetivo: comparar identidad y contenido.
        // Datos iniciales: dos objetos nuevos con el texto "luna".
        // Acción exacta: guarda este código sin cambios en Igualdad.java.
        // Cálculo: a == b comprueba identidad; a.equals(b), contenido.
        // El entrevistador escucha: predicción y explicación de new.
        public class Igualdad {
            public static void main(String[] args) {
                String a = new String("luna");
                String b = new String("luna");
                System.out.println(a == b);
                System.out.println(a.equals(b));
            }
        }
        // Ejecuta en la terminal:
        // java Igualdad.java
        // Salida esperada:
        // false
        // true

        Practica lo que enseña este artículo

        Las claves y el recuento con HashMap

        HashMap asocia claves con valores y utiliza el código hash para localizar posibles coincidencias, comprobando después la igualdad. Su funcionamiento depende de que ambos mecanismos respeten el mismo contrato.

        5. «¿Qué relación deben mantener equals y hashCode, y qué problema puede causar una clave mutable en un HashMap?»
        
        Respuesta modelo: Si dos objetos son iguales según equals, deben producir el mismo hashCode. Dos objetos con el mismo hashCode no tienen por qué ser iguales. Si cambian los campos usados por esos métodos después de insertar una clave, una búsqueda puede dejar de encontrar la entrada porque intenta localizarla con un código hash distinto.
        
        El entrevistador escucha: la dirección correcta de la implicación y una justificación de por qué conviene que los campos usados por la clave no cambien.

        Antes del segundo ejercicio, puedes ensayar tu explicación en la práctica de entrevista de Java de The Work Gym. El Interview Hub ofrece entrevistas de práctica habladas y escritas con un informe escrito; para comprobar el código, también puedes ejecutarlo localmente.

        Guarda el siguiente programa como Conteo.java y ejecútalo desde su carpeta. Un record declara componentes y genera, entre otros métodos, igualdad y código hash basados en ellos; aquí, el componente String es inmutable. La operación merge suma al valor existente cuando encuentra una clave equivalente.

        // 6. «Cuenta dos registros del mismo cliente con un HashMap,
        // usando dos instancias distintas de una clave definida por ti».
        //
        // Respuesta modelo y especificación del ejercicio ficticio:
        // Entorno: JDK 17. Archivo: Conteo.java.
        // Objetivo: agrupar por correo exacto, distinguiendo mayúsculas.
        // Datos iniciales: dos registros con "[email protected]".
        // Estado inicial: mapa vacío.
        // Acción exacta: guarda este código sin cambios en Conteo.java.
        // Modelo: cada registro aporta 1; 1 + 1 = 2 para una clave lógica.
        // Comprobación: buscar con una tercera instancia equivalente.
        // El entrevistador escucha: igualdad por valor y acumulación.
        import java.util.HashMap;
        import java.util.Map;
        
        public class Conteo {
            record Cliente(String correo) {}
        
            public static void main(String[] args) {
                Map<Cliente, Integer> conteos = new HashMap<>();
                conteos.merge(new Cliente("[email protected]"), 1, Integer::sum);
                conteos.merge(new Cliente("[email protected]"), 1, Integer::sum);
                System.out.println(conteos.size());
                System.out.println(conteos.get(new Cliente("[email protected]")));
            }
        }
        // Ejecuta en la terminal:
        // java Conteo.java
        // Salida esperada:
        // 1
        // 2
        // Límite: no se normalizan correos ni se valida su formato.

        La primera línea confirma que existe una sola clave lógica; la segunda confirma el recuento. Buscar con una tercera instancia es importante: reutilizar la referencia original no demostraría que dos instancias equivalentes funcionan como la misma clave. Una clase que heredase la igualdad por identidad de Object produciría dos entradas independientes.

        Las excepciones y las decisiones de colección

        Elegir una excepción o una colección exige justificar qué necesita el programa. Una respuesta sólida distingue el contrato general de una interfaz de los detalles de su implementación.

        7. «¿Qué diferencia hay entre una excepción comprobada y una no comprobada, y dónde manejarías cada una?»
        
        Respuesta modelo: Las excepciones comprobadas deben capturarse o declararse cuando pueden propagarse desde una operación. Las subclases de RuntimeException y de Error no están sujetas a esa comprobación del compilador. Manejaría una excepción donde pueda recuperar la operación o traducir el fallo a una respuesta útil, conservando su causa. No capturaría Exception para ignorar el error ni trataría Error como un fallo de negocio recuperable.
        
        El entrevistador escucha: diferencia entre obligación del compilador y estrategia de recuperación, además de conservación del contexto del fallo.
        8. «¿Cuándo elegirías List, Set o Map, y qué coste esperarías al buscar elementos?»
        
        Respuesta modelo: List representa una secuencia y permite duplicados; Set representa elementos sin duplicados según su contrato; Map asocia claves con valores. El coste depende de la implementación y la operación: contains en ArrayList requiere un recorrido lineal; contains en HashSet y get en HashMap tienen coste esperado constante con una dispersión adecuada de los códigos hash. No todos los Set ni todos los Map ofrecen ese coste.
        
        El entrevistador escucha: elección según orden, duplicados y acceso por clave; distinción entre interfaz, implementación y coste esperado.

        Un coste lineal crece con la cantidad de elementos recorridos; un coste esperado constante no crece proporcionalmente al tamaño bajo las condiciones indicadas. Evita convertir esa expectativa en una garantía para cualquier entrada.

        La concurrencia y el ensayo razonado

        La concurrencia permite que varias tareas progresen durante un mismo intervalo y exige distinguir visibilidad de atomicidad. La visibilidad trata de observar cambios entre hilos; la atomicidad, de realizar una operación de forma indivisible.

        9. «Dos hilos incrementan un contador compartido. ¿Por qué puede perderse un incremento y cómo lo resolverías?»
        
        Respuesta modelo: Incrementar implica leer, calcular y escribir; dos hilos pueden leer el mismo valor y sobrescribir sus resultados. Para un contador independiente usaría AtomicInteger con incrementAndGet. Si el contador participa en una condición que involucra varios campos, protegería toda la operación mediante la misma sincronización, por ejemplo con synchronized. Una colección concurrente no vuelve atómica cualquier secuencia de operaciones.
        
        El entrevistador escucha: identificación de la operación compuesta y elección del mecanismo según el estado protegido.
        10. «¿Declarar volatile un contador hace seguro su incremento desde varios hilos?»
        
        Respuesta modelo: No. volatile aporta garantías de visibilidad y orden entre accesos, pero no convierte la lectura, suma y escritura en una operación indivisible. Puede servir para una bandera de parada que un hilo escribe y otro consulta, sin condiciones compuestas adicionales. Para incrementar un contador compartido usaría una operación atómica o sincronización.
        
        El entrevistador escucha: separación entre visibilidad y atomicidad, un uso acotado de volatile y coherencia con la solución anterior.

        Ensaya sin mirar las respuestas y usa esta secuencia para detectar lagunas:

        • Define el concepto y nombra el tipo o la operación a la que se aplica.
        • Predice las salidas de ambos programas y ejecútalos para contrastarlas.
        • Explica un error posible y cómo lo detectarías.
        • Distingue lo que has comprobado de lo que todavía no has demostrado.

        Esta selección no cubre Spring, persistencia ni diseño de sistemas. Tampoco una ejecución correcta demuestra que un programa concurrente esté libre de errores: debes razonar sobre las posibles interacciones entre hilos.

        Preguntas frecuentes

        ¿Qué temas conviene repasar para una entrevista técnica Java de nivel inicial? Empieza por ejecución, tipos, referencias, igualdad, colecciones y excepciones. Comprueba que puedes explicar y ejecutar los dos ejercicios antes de ampliar el repaso a concurrencia.

        ¿Cómo explicar una solución cuando no recuerdas un método de Java? Describe la operación necesaria, los datos de entrada y el resultado esperado sin inventar una firma. Si puedes consultar documentación, verifica el método y prueba el caso mínimo antes de incorporarlo a la solución.

        ¿Qué diferencia una respuesta sobre igualdad de una demostración correcta? Una demostración usa objetos distintos y predice el resultado antes de ejecutar. Para una clave de mapa, también comprueba la recuperación con otra instancia equivalente, no solo con la referencia insertada.

        ¿Cuándo conviene preparar Spring además de los fundamentos de Java? Cuando la descripción del puesto o las instrucciones de la prueba incluyan Spring. Mantén el repaso de Java: el uso de un framework no reemplaza los contratos de igualdad, las colecciones ni el manejo de excepciones.

        Si el proceso incluye razonamiento numérico, lógico o verbal, puedes preparar esa parte por separado con el Test de aptitud. No sustituye la preparación técnica de Java.

        Practica lo que enseña este artículo

        Your Work Gym account

        Save your progress and pick up on another device. Your browser's progress comes with you.

        or

        You can keep practicing without an account.

        Ayuda y comentarios

        Haz una pregunta, cuéntanos qué no funciona o comparte una idea. Te respondemos por correo electrónico.

        ¿De qué se trata?

        Solo lo usamos para responderte.