Array de objetos

Una característica importante de los arrays, es que todos los elementos deben ser del mismo tipo.

Hasta ahora, hemos estudiado arrays con elementos de tipos primitivos. Sin embargo, también se puede crear arrays con elementos de cualquier tipo de datos, incluidas las referencias a objetos.

Recordemos que, cuando hacemos String str;, se declara una variable llamada str que almacena la referencia a un objeto de tipo String, pero el objeto todavía no ha sido creado.

Un objeto existe solo después de haber sido construido. Los objetos se construyen solo mientras se ejecuta un programa cuando se invoca el constructor.

Una vez construido, se accede a un objeto siguiendo una referencia al objeto. A menudo, la referencia se mantiene en una variable de referencia como str.

En el siguiente ejemplo, se declara una variable de referencia, se construye un objeto y luego la referencia al objeto se coloca en la variable de referencia:

String str;             // declara una variable de tipo referencia
str = "Hello World" ;   // construye el objeto y 
                        // almacena su referencia

Array de Strings

Para declarar un array de Strings ser realizaría de la siguiente forma:

String[] array = new String[5];

array[0] = "Hello";
array[1] = "World";
...

Cada objeto String del ejemplo es un String normal. Nada en él ha cambiado porque su referencia se mantiene en el array. Cada cadena puede tener cualquier número de caracteres.

Array de objetos

Al igual que los arrays de string, odemos tener un array de cualquier tipo de clase. Cada elemento del array apuntará a una instancia del tipo de la clase o a null.

Podemos ver en el ejemplo una clase de tipo Alumno y un array de alumnos en el que se crean algunas instancias del array.

public class Alumno {
    private String nombre;
    private int nota;

    public Alumno(String nombre, int nota) {
        this.nombre = nombre;
        this.nota = nota;
    }
    public void mostrarAlumno() {
        System.out.println( "Alumno: " + nombre + " nota:" + nota);
    }
}

Si declaramos un array de Alumnos, hay que crear las instancias para cada posición del array como vemos en las dos primeras líneas marcadas

 public static void main(String[] args) {
        //creamos una array de Alumnos
        Alumno[] dam1k = new Alumno[5];
        //creamos dos alumnos en las dos primeras posiciones
        dam1k[0] = new Alumno("Pepe", 7);
        dam1k[1] = new Alumno("Maria", 9);
        //mostramos alumnos 
        dam1k[0].mostrarAlumno();
        dam1k[1].mostrarAlumno();
        //produce el error NullPointerException
        dam1k[2].mostrarAlumno();

    }

Vemos en la última línea marcada como se intenta acceder a una instancia de la posición 2 pero no se ha creado una instancia, esto producirá un error en tiempo de ejecución NullPointerException

Otras formas de inicio de los arrays de objetos

Inicializar todos los objetos directamente

Alumno[] dam1k = {
    new Alumno("Pepe", 7),
    new Alumno("Maria", 9),
    new Alumno("Juan", 5),
    new Alumno("Ana", 8),
    new Alumno("Pedro", 6)
};

Inicializar con un bucle

Alumno[] dam1k = new Alumno[5];

for (int i = 0; i < dam1k.length; i++) {
    dam1k[i] = new Alumno("Alumno" + i, 0); // inicialización básica
}

Evitar error de nulos: NullPointerException

Deberíamos siempre comprobar si un elemento es null antes de su uso. Dependerá siempre de las características del problema. Existen lenguajes como Kotlin, que te obligan siempre a comprobarlo.

if (dam1k[2] != null) {
    dam1k[2].mostrarAlumno();
} else {
    System.out.println("El alumno 2 todavía no existe.");
}

Argumentos de línea de comandos: String[] args

Como ya sabemos el método main recibe un array de Strings como parámetro:

    public static void main(String[] args) {
    }

• main recibe una referencia a un array de referencias de String.

• Este array es construido por el sistema Java justo antes de que main() obtenga el control.

• Los elementos que contiene el array son cadenas de texto que se pasan en la línea de comando que inicia el programa.

Por ejemplo, digamos que un programa se inicia con esta línea de comando llamado Demo.java para guardar el nombre y la edad:

java Demo pepe 25

Donde Demo es el nombre del programa, pepe es el primer argumento y 25 el segundo.

Por tanto args[0] contendrá pepe y args[1] 25.

Puede haber cualquier número de argumentos en la línea de comandos. Los argumentos son siempre cadenas de caracteres. Cada argumento está separado del resto por espacios.

public class Demo {
    public static void main(String[] args) {
        System.out.println("Número de argumentos: " + args.length);
        //muestra los argumento
        /*for (int i = 0; i < args.length; i++) {
            System.out.println("Argumento " + i + ": " + args[i]);
        }*/
       //comprobamos que tenemos los argumento necesarios
       String nombre;
       int edad;
       if(args.legth==2){
        System.out.println("Guardando datos...");
        nombre=args[0];
        edad=Integer.parseInt(args[1]);
        //...
       }
    }
}

Convertir String en tipo primitivo

Si tenemos que transformar un String que representa un tipo primitivo(int, float...), utilizaremos los métodos static de la clase envoltorio(Wrapper Classes).

    // --- 1. Conversión a Entero (int) ---
    String strEntero = "12345";    
    int numeroInt = Integer.parseInt(strEntero);
    // --- 2. Conversión a Decimal  (double) 
    String strDecimal = "98.765";
    double numeroDouble = Double.parseDouble(strDecimal);