ArrayList – JAVA SIN IA

Correspondencia en Python —>

Los ArrayList son un tipo de estructura de datos con algunas características comunes con la estructura List.

Ambos son una estructura ordenada de elementos del mismo tipo.
Comienzan por el elemento 0
Pueden tener elementos repetidos.
El contenido de cada uno de sus elementos, puede ser modificado.
Puede haber ArraysList de dos o más dimensiones. Incluso cada una de sus dimensiones, puede tener diferente cantidad de elementos.

Entre otras muchas diferencias tenemos:

Su tamaño puede variar, ya que se pueden añadir y eliminar elementos.
Sus índices se encierran entre paréntesis.
Los métodos y funciones que se les aplican son casi todos distintos.

import java.util.ArrayList;

public class Prueba {
    public static void main(String[] args) {
        ArrayList<Integer> medidas= new ArrayList<Integer>();
        medidas.add(40);
        medidas.add(30);
        medidas.add(20);
        System.out.println("Las medidas de equipaje admitido son:");
        System.out.println("Alto: "+medidas.get(0) +". Largo:"+medidas.get(1) +". Ancho: "+medidas.get(2));
    }
}

Resultado:

Las medidas de equipaje admitido son:
Alto: 40. Largo:30. Ancho: 20

En este ejemplo, hemos declarado el ArrayList (su tamaño será 0 por defecto), a continuación hemos añadido 3 elementos. Si entre los paréntesis de la declaración indicamos un número entero, establecemos que el ArrayList tendrá un tamaño inicial de ese entero, aunque inicialmente todos sus elementos tendrán un valor «null».

También podemos declarar e inicializar a la vez sus primeros elementos, aunque la forma de hacerlo es diferente al ejemplo anterior, y debemos de importar un par de métodos más de java.util

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<Integer> medidas = new ArrayList<>(Arrays.asList(40,30,20));

        System.out.println("Las medidas de equipaje admitido son:");
        System.out.println("Alto: "+medidas.get(0) +". Largo:"+medidas.get(1) +". Ancho: "+medidas.get(2));
    }
}

Resultado:

Las medidas de equipaje admitido son:
Alto: 40. Largo:30. Ancho: 20

Según el tipo de dato que contengan, la forma de declararlo es diferente, puede ser:

ArrayList<Integer> si contiene datos tipo int
ArrayList<String> si va a contener cadenas.
ArrayList<Double> para tipos double.
ArrayList<Float> para tipos float.
ArrayList<Boolean> para tipo boolean
ArrayList<nombre_clase> si va a contener objetos de una clase.

Veamos otro ejemplo. A diferencia de con Array (que debíamos pasarlos previamente todos a una cadena), podemos imprimir directamente todos los elementos que contiene un ArrayList.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> medidas = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaquín", "Morata", "Pedri"));

        System.out.println(medidas);
        
    }
}

Resultado:
[Cristiano, Messi, Joaquín, Morata, Pedri]

Los ArrayList comienzan con el primer elemento con índice 0. Podemos dar un nuevo valor a cualquier elemento simplemente asignándole el nuevo valor.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaquín", "Morata", "Pedri"));
        System.out.println("Mi jugador preferido es "+jugadores.get(0));
        System.out.println("El máximo goleador es "+jugadores.get(2));
        jugadores.set(1,"Cucurella");
        System.out.print(jugadores);
    }

Resultado:

Mi jugador preferido es Cristiano
El máximo goleador es Joaquín
[Cristiano, Cucurella, Joaquín, Morata, Pedri]

Vemos que para acceder a los elementos de un ArrayList se utiliza el método .get(posición) que nos da el valor del elemento contenido en dicha posición.

También vemos que para variar el valor de un determinado elemento usamos el método .set (posición,nuevo_valor), que cambia el valor del elemento que se encuentre en esa posición por el nuevo valor.

El método .add(nuevo_elemento) nos añade un nuevo elemento al final del ArrayList y el método .size( ) nos facilita el total de elementos que contiene.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaquín", "Morata", "Pedri"));
        jugadores.add("Casillas");
        System.out.println(jugadores);
        int total_elementos=jugadores.size();
        System.out.println("El total de jugadores es: "+total_elementos);
    }
}

Resultado:

[Cristiano, Messi, Joaquín, Morata, Pedri, Casillas]
El total de jugadores es: 6

También podemos insertar un elemento en una determinada posición con el método .add (posición, nuevo_elemento)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaquín", "Morata", "Pedri"));
        jugadores.add(2,"Pedri");
        System.out.println(jugadores);
    }
}

Resultado:
[Cristiano, Messi, Pedri, Joaquín, Morata, Pedri]

Con el método .remove(índice) eliminamos el elemento que se encuentre en la posición del índice indicada; y con .remove(valor) eliminamos el primer elemento de la lista que posea el valor indicado.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaquín", "Morata", "Pedri","Cristiano"));
        jugadores.add(2,"Pedri");
        System.out.println(jugadores);
        jugadores.remove(1);
        jugadores.remove("Cristiano");
        //jugadores.removeIf(jugador ->jugador.startsWith("C"));
        System.out.println(jugadores);
    }
}

Resultado:

[Cristiano, Messi, Pedri, Joaquín, Morata, Pedri, Cristiano]
[Pedri, Joaquín, Morata, Pedri, Cristiano]

Con .removeIf( elemento -> condición) eliminamos todos los elementos del ArrayList que cumpla una determinada condición. En el siguiente ejemplo, eliminamos todos los elementos que comiencen por «Cri»

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaquín", "Morata", "Pedri","Cristiano"));
        jugadores.add(2,"Pedri");
        jugadores.removeIf(jugador ->jugador.startsWith("Cri"));
        System.out.println(jugadores);
    }

[Messi, Pedri, Joaquín, Morata, Pedri]

Otro ejemplo. Ahora eliminamos todos los números mayores que 100.

public class Prueba2 {
    public static void main(String[] args) {
        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(3,44,32,401,178));
        mis_numeros.removeIf(numero -> numero>100);
        System.out.println(mis_numeros);
    }
}

Resultado:

[3, 44, 32]

A partir de un ArrayList podemos obtener otro ArrayList extraído de una porción del primero. El método a aplicar es .subList(inicio,fin) con el cual obtendremos un segmento de ArrayList que se inicia en el elemento inicio y finaliza en el elemento fin (que no estará incluído).

En los siguientes ejemplos, nos hemos ayudado en algunos de ellos de la variable «fin» que hemos declarado para conocer el tamaño del ArrayList y poder añadirlo como margen superior del segmento. Debemos de tener en cuenta que el elemento fin no va a estar incluido.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba2 {
    public static void main(String[] args) {
        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,3,5,7,11,13,17,19,23,29));
        int fin=mis_numeros.size(); //tamaño del ArrayList.
        List<Integer> segmento_1 = mis_numeros.subList(2, (fin-2));
        List<Integer> segmento_2 = mis_numeros.subList(0, 6);
        List<Integer> segmento_3 = mis_numeros.subList(3, fin);
        List<Integer> segmento_4 = mis_numeros.subList(2, 7);
        System.out.println(segmento_1);
        System.out.println(segmento_2);
        System.out.println(segmento_3);
        System.out.println(segmento_4);
    }
}

Resultado:

[5, 7, 11, 13, 17, 19]
[1, 3, 5, 7, 11, 13]
[7, 11, 13, 17, 19, 23, 29]
[5, 7, 11, 13, 17]

Tratar un String como un ArrayList. Para muchas operaciones podemos trabajar con un dato tipo String como si fuese un ArrayList.

public class Prueba3 {
    public static void main(String[] args) {
        String texto = "Hola, soy una cadena y también un ArrayList.";
        int tamanyo=texto.length();
        String segmento_1=texto.substring(0,6);
        String segmento_2=texto.substring(14,21);
        String nuevo_texto="";
        String excluidos="aeiou";
        for (int k=0; k<tamanyo; k+=1){
            char letra=texto.charAt(k);
            if (excluidos.indexOf(letra) == -1){
               nuevo_texto=nuevo_texto+letra;
            }
        }
        System.out.println("La cadena tiene "+tamanyo+" caracteres.");
        System.out.println(segmento_1+segmento_2);
        System.out.println(nuevo_texto);

    }
}

Resultado:

La cadena tiene 44 caracteres.
Hola, cadena 
Hl, sy n cdn y tmbén n ArryLst.

Primer hemos averiguado el tamaño del String. Luego hemos extraídos dos segmentos de dicho String y los hemos sumado. A continuación lo hemos recorrido para extraerles los caracteres que estaban incluidos en otro String.

Con el método .split(«separador») podemos obtener un ArrayList de Strings a partir de un String inicial. El parámetro separador (que irá siempre entre comillas) indica el punto en que se divide cada uno de los segmentos de ArrayList que pasarán al nuevo. Si el separador es un espacio en blanco, debemos de indicar el espacio en blanco entre las comillas.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba3 {
    public static void main(String[] args) {
        String texto = "Este verano está siendo muy caluroso";
        List<String> pasar_List = Arrays.asList(texto.split(" "));
        ArrayList<String> mi_lista = new ArrayList<>(pasar_List);
        System.out.println(mi_lista);
    }
}

Resultado:

[Este, verano, está, siendo, muy, caluroso]

Podemos añadir un parámetro adicional al método .split que indique el número máximo de segmentos que debe de extraer:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba3 {
    public static void main(String[] args) {
        String texto = "Este verano está siendo muy caluroso";
        List<String> pasar_List = Arrays.asList(texto.split(" ",3));
        ArrayList<String> mi_lista = new ArrayList<>(pasar_List);
        System.out.println(mi_lista);
    }
}

Resultado:
[Este, verano, está siendo muy caluroso]

El método contrario es String.join(«delimitador»,ArrayList) que toma un ArrayList de String y forma a partir del mismo un único String que tendrá como separador el delimitador indicado entre comillas como primer parámetro.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba3 {
    public static void main(String[] args) {
        List<String> mi_lista = new ArrayList<>(Arrays.asList("Este", "verano", "está", "siendo", "muy", "caluroso"));
        String mi_frase = String.join(" ",mi_lista);
        System.out.println(mi_frase);
    }
}

Resultado:

Este verano está siendo muy caluroso

Para vaciar un ArrayList la forma más eficiente es utilizar el método .clear( )

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba2 {
    public static void main(String[] args) {
        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,3,5,7,11));
        System.out.println(mis_numeros);
        mis_numeros.clear();
        System.out.println(mis_numeros);
    }
}

Resultado:

[1, 3, 5, 7, 11]
[]

El método .addAll(otro_ArrayList) permite añadir todos los elementos del ArrayList que figura como parámetro al ArrayList original.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba2 {
    public static void main(String[] args) {
        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,3,5,7,11));
        List<Integer> tus_numeros = new ArrayList<>(Arrays.asList(18,32,143));
        List<Integer> total_numeros = new ArrayList<>();
        total_numeros.addAll(mis_numeros);
        total_numeros.addAll(tus_numeros);

        System.out.println(mis_numeros);
        System.out.println(tus_numeros);
        System.out.println(total_numeros);
    }
}

Resultado:

[1, 3, 5, 7, 11]
[18, 32, 143]
[1, 3, 5, 7, 11, 18, 32, 143]

Es posible que debamos recorrer todos los elementos de un ArrayList por diversas circunstancias. Por ejemplo, para sumar todos sus elementos, saber sus elementos son mayores (o menores) que un valor determinado…

En el siguiente ejemplo, recorremos el ArrayList y sumamos todos sus elementos:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<Double> mis_numeros = new ArrayList<>(Arrays.asList(13.4,3.87,5.0,7.0,11.0));
        double suma=0;
        for (double numero : mis_numeros){
            suma=suma+numero;
        }
        double total=Math.round(suma * 100.0) / 100.0;
        System.out.println("Todos los números suman: "+total);
    }
}

Resultado:

Todos los números suman: 40.27

Si queremos saber las veces que aparece un determinado elemento en un ArrayList, podemos utilizar el método Collections.frequency(ArrayList, elemento):

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<Double> mis_numeros = new ArrayList<>(Arrays.asList(5.3,3.87,5.3,7.0,11.0,5.3));
        int repeticiones= Collections.frequency(mis_numeros,5.3);
        System.out.println("El número 5.3 aparece "+repeticiones+" veces.");
    }
}

Resultado:

El número 5.3 aparece 3 veces.

El método Collections.max(ArrayList) nos permite obtener el valor máximo contenido en un ArrayList:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<Double> mis_numeros = new ArrayList<>(Arrays.asList(5.3,3.87,5.3,7.0,11.0,5.3));
        double el_maximo= Collections.max(mis_numeros);
        System.out.println("El número mayor es el: "+ el_maximo);
    }
}

Resultado:

El número mayor es el: 11.0

De la misma manera el método Collections.min(ArrayList) nos devuelve el mínimo valor de un ArrayList:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<Double> mis_numeros = new ArrayList<>(Arrays.asList(5.3,3.87,5.3,7.0,11.0,5.3));
        double el_minimo= Collections.min(mis_numeros);
        System.out.println("El número menor es el: "+ el_minimo);
    }
}

Resultado:

El número menor es el: 3.87

Estos dos métodos anteriores aplicados a ArrayList de String, tomaría como valores máximos y mínimos los códigos ASCII del primer (o siguientes) caracteres de cada String.

Debemos de tener en cuenta que los caracteres en mayúsculas tienen un código ASCII menor que los que están en minúsculas, de ahí se explica el resultado del siguiente código.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> mis_palabras = new ArrayList<>(Arrays.asList("Tomate","pera","calabaza","Calabaza","melón","Zanahoria"));
        String el_maximo= Collections.max(mis_palabras);
        System.out.println(mis_palabras);
        System.out.println("La palabra mayor es el: "+ el_maximo);
    }
}

Resultado:

[Tomate, pera, calabaza, Calabaza, melón, Zanahoria]
La palabra mayor es el: pera

El método Collections.reverse(ArrayList) permite invertir completamente el orden de los elementos de un ArrayList:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> mis_palabras = new ArrayList<>(Arrays.asList("Tomate","pera","calabaza","Calabaza","melón","Zanahoria"));
        System.out.println(mis_palabras);
        Collections.reverse(mis_palabras);
        System.out.println(mis_palabras);
    }
}

Resultado:

[Tomate, pera, calabaza, Calabaza, melón, Zanahoria]
[Zanahoria, melón, Calabaza, calabaza, pera, Tomate]

Collections.sort(ArrayList) ordenará un ArrayList en orden ascendente numérico o en orden ascendente por código ASCII

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> mis_palabras = new ArrayList<>(Arrays.asList("Tomate","pera","calabaza","Calabaza","melón","Zanahoria"));
        System.out.println(mis_palabras);
        Collections.sort(mis_palabras);
        System.out.println(mis_palabras);
    }
}

Resultado:

[Tomate, pera, calabaza, Calabaza, melón, Zanahoria]
[Calabaza, Tomate, Zanahoria, calabaza, melón, pera]

Collections.binarySearch(ArrayList, elemento) Este método permite obtener la posición que ocupa un determinado elemento en un ArrayList.

Si el elemento no está en el ArrayList dará un resultado negativo.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<String> mis_palabras = new ArrayList<>(Arrays.asList("Tomate","melón","pera","piña","calabaza","Calabaza","Zanahoria"));
        System.out.println(mis_palabras);
        int posicion=Collections.binarySearch(mis_palabras, "melón");
        System.out.println("La palabra 'melón' está en la posición "+posicion);
    }
}

Resultado:

[Tomate, melón, pera, piña, calabaza, Calabaza, Zanahoria]
La palabra 'melón' está en la posición 1

Interesante es el método Collections.shuffle(ArrayList) que ordena todos los elementos del ArrayList de forma aleatoria.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9,10));
        System.out.println(mis_numeros);
        Collections.shuffle(mis_numeros);
        System.out.println(mis_numeros);
    }
}

Posible resultado:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[6, 1, 5, 8, 9, 3, 4, 7, 2, 10]

Con el método Collections.fill(ArrayList, elemento) reemplazamos todos los elementos de la lista con el elemento que se indica como parámetro.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9,10));
        System.out.println(mis_numeros);
        Collections.fill(mis_numeros, 0);
        System.out.println(mis_numeros);
    }
}

Resultado:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

El método Collections.copy(destino,origen) copia todos los elementos del ArrayList origen en el nuevo ArrayList destino. Es indispensable que el ArrayList destino tenga el mismo tamaño (o mayor) que el ArrayList origen. Cada uno de los elementos de origen es copiado a su elemento correspondiente del destino. Veamos un ejemplo:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba {
    public static void main(String[] args) {
        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9,10));
        List<Integer> nuevos_numeros = new ArrayList<>(Arrays.asList(new Integer[mis_numeros.size()]));

        nuevos_numeros.add(787);
        nuevos_numeros.add(583);
        System.out.println(mis_numeros);
        System.out.println(nuevos_numeros);
        Collections.copy(nuevos_numeros,mis_numeros);
        System.out.println(nuevos_numeros);
    }
}

Resultado:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[null, null, null, null, null, null, null, null, null, null, 787, 583]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 787, 583]

El método Collections.replaceAll(ArrayList,valor_antes,valor_después) nos facilita cambiar todas las apariciones en el ArrayList de un determinado valor (valor_antes) y cambiarlo por un nuevo valor (valor_después):

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prueba2 {
    public static void main(String[] args) {
        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,1,173,824,1,3,5,7,11));
        System.out.println(mis_numeros);
        Collections.replaceAll(mis_numeros,1,0);
        System.out.println(mis_numeros);
    }
}

Resultado:

[1, 1, 173, 824, 1, 3, 5, 7, 11]
[0, 0, 173, 824, 0, 3, 5, 7, 11]

Inicio	Comandos Java	Bloques de código.
Comentar código	System.out.print	Scanner (System.in)
Captura de errores	String	Datos Numéricos
Elementos aleatorios	Datos Fecha/hora	Constantes
Bucles for	Bucles while	Bloque if
Arrays	ArrayList	switch case
HashSet	HashMap	Métodos.
Clases	Archivos	Entorno gráfico Swing
JFrame (Ventanas)	Componentes básicos.