← Volver a actividades
Autoevaluación

Autoevaluación: Arrays de Objetos

Arrays de Objetos: Guardar y Recorrer Muchas Instancias · 15 min aprox.

Respondé todas las preguntas y presioná Calificar para ver tu puntaje.

1. Al declarar Persona[] personas = new Persona[5];, ¿qué estructura se reserva exactamente en memoria?
Correcto Incorrecto Sin responder

Respuesta correcta: Se reservan 5 casillas contiguas preparadas para almacenar referencias a objetos Persona, todas inicializadas en null.

¿Por qué? Un array de objetos no guarda los objetos en sus casillas, sino direcciones de memoria (referencias). Al ejecutar new Persona[5], la JVM solo reserva el bloque de 5 casillas vacías (null). Cada objeto debe ser creado explícitamente en un segundo paso mediante new Persona(...).

2. El siguiente código compila sin errores pero lanza un NullPointerException en tiempo de ejecución:
Persona[] equipo = new Persona[3];
System.out.println(equipo[0].getNombre());
Correcto Incorrecto Sin responder

Respuesta correcta: Verdadero

¿Por qué? new Persona[3] reserva 3 casillas donde cada elemento comienza valiendo null. El compilador lo acepta porque la expresión es sintácticamente válida, pero al intentar desreferenciar equipo[0] invocando un método sobre una casilla vacía, la JVM arroja inmediatamente NullPointerException.

3. ¿Cuál es la principal ventaja de utilizar la inicialización literal { new Persona(...), new Persona(...) }?
Correcto Incorrecto Sin responder

Respuesta correcta: Reserva el array y construye cada instancia en una sola expresión, garantizando que ninguna casilla quede en null.

¿Por qué? La sintaxis literal fusiona en un paso atómico la reserva del array y la construcción de cada objeto. Su longitud coincide exactamente con la cantidad de instancias provistas y elimina por completo el riesgo de dejar casillas con null.

4. En el siguiente método de búsqueda lineal, ¿por qué es indispensable evaluar p != null antes que p.getNombre()?
public static Persona buscar(Persona[] personas, String nombre) {
    for (Persona p : personas) {
        if (p != null && p.getNombre().equalsIgnoreCase(nombre)) {
            return p;
        }
    }
    return null;
}
Correcto Incorrecto Sin responder

Respuesta correcta: Por la evaluación de cortocircuito del operador &&: si p es null, la segunda parte no se ejecuta y se evita un NullPointerException.

¿Por qué? Java utiliza cortocircuito en las operaciones lógicas: si la condición izquierda de un && resulta falsa (p es null), el motor no evalúa la expresión derecha. Si invirtiéramos el orden, al procesar la primera casilla vacía el programa intentaría llamar a .getNombre() sobre null y fallaría con NullPointerException.

5. Al ordenar un array de objetos intercambiando posiciones con una variable temporal como en el siguiente snippet, ¿qué ocurre en memoria?
Persona temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
Correcto Incorrecto Sin responder

Respuesta correcta: Se intercambian únicamente las referencias contenidas en las casillas del array; los objetos en el Heap no se mueven ni se duplican.

¿Por qué? Un array de objetos almacena flechas (referencias). Al realizar el swap mediante la variable temporal, únicamente se reasignan las direcciones que guardan las casillas del array. Los objetos permanecen intactos en su posición original del Heap sin duplicar datos ni consumir memoria extra.

6. ¿Qué imprime la última línea del siguiente código?
Persona[] plantel = { new Persona("Ana", 20), new Persona("Beto", 25) };
plantel[1] = plantel[0];
System.out.println(plantel[1].getNombre() + " " + plantel[1].getEdad());
Correcto Incorrecto Sin responder

Respuesta correcta: Ana 20, porque las dos casillas ahora apuntan al mismo objeto "Ana"; el objeto "Beto" queda sin ninguna referencia.

¿Por qué? plantel[1] = plantel[0] copia la flecha (la referencia), no el objeto. Después de esa línea, las casillas 0 y 1 apuntan al mismo objeto "Ana", por eso se imprime Ana 20. No se crea ninguna copia: sigue habiendo un solo objeto "Ana" en el Heap. El objeto "Beto" pierde su única referencia y queda libre para que el Garbage Collector lo recolecte.

7. En una clase que administra un array parcialmente lleno con un contador int cantidad, los bucles que recorren el array deben iterar hasta datos.length.
Correcto Incorrecto Sin responder

Respuesta correcta: Falso

¿Por qué? datos.length indica la capacidad física total reservada, donde las casillas libres contienen null. cantidad representa cuántas casillas fueron efectivamente ocupadas por objetos válidos. Recorrer hasta datos.length provocaría NullPointerException al llegar a la primera posición vacía. La regla fundamental es iterar estrictamente hasta i < cantidad.

8. Mirá la clase Curso y el código que la usa. Después de ejecutar la última línea, el array alumnos que está guardado adentro del curso también quedó con null en la posición 0.
public class Curso {
    private final Persona[] alumnos;

    public Curso(Persona[] lista) {
        this.alumnos = Arrays.copyOf(lista, lista.length);
    }

    public Persona[] getAlumnos() {
        return this.alumnos;   // devuelve la flecha al array interno
    }
}

// Código de otra clase que usa a Curso:
Curso curso = new Curso(new Persona[] { new Persona("Ana", 20) });
Persona[] lista = curso.getAlumnos();
lista[0] = null;
Correcto Incorrecto Sin responder

Respuesta correcta: Verdadero

¿Por qué? getAlumnos() no devuelve una copia: devuelve la misma referencia que guarda el atributo alumnos. Entonces lista y curso.alumnos son dos flechas al MISMO array, y lista[0] = null borra al alumno adentro del curso. Que el atributo sea private impide escribir curso.alumnos, y que sea final impide reasignarlo a otro array, pero ninguna de las dos cosas protege las casillas. Así se rompe el encapsulamiento: código de afuera cambió el estado interno sin pasar por ningún método de Curso. La solución es la misma que en el constructor: devolver una copia con return Arrays.copyOf(alumnos, alumnos.length);. Así quien llama recibe su propio array y puede modificarlo sin tocar el del curso.