Clase ArrayList en Java

¡Hola! En conferencias anteriores, examinamos en detalle una estructura de datos como una matriz y analizamos ejemplos comunes de cómo trabajar con ellos. Pero esta estructura de datos tiene una serie de desventajas. La respuesta en Java fue la aparición de ArrayList. Para decirlo de la manera más simple posible, un ArrayList en Java es una matriz "actualizada" con muchas características nuevas.

¿En qué se diferencia Java Arraylist de las matrices normales?

En general, las matrices son bastante convenientes y, como ya habrás notado, puedes hacer muchas cosas con ellas :) Sin embargo, las matrices también tienen una serie de desventajas.

• Tamaño limitado. Ya en la etapa de creación de una matriz necesita saber cuántas celdas debe contener. Si subestima la cantidad requerida, no habrá suficiente espacio. Si lo sobreestimas, la matriz quedará medio vacía, y eso no es tan malo. Después de todo, resulta que también le asignará más memoria de la necesaria.
• Una matriz no tiene métodos para agregar elementos. Siempre debes especificar explícitamente el índice de la celda donde deseas agregar el elemento. Si accidentalmente especifica una celda ya ocupada con algún valor deseado, se sobrescribirá.
• No existen métodos para eliminar un elemento. El valor sólo se puede "poner a cero".

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Tomás");
       cats[1] = new Cat("Hipopótamo");
       cats[2] = new Cat("Felipe Markovich");

       cats[1] = null;



       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

Conclusión:

[Cat{name='Томас'}, null, Cat{name='Фoпп Маркович'}]

Todas estas deficiencias se pueden eliminar utilizando ArrayList. Se crea de forma muy sencilla:

ArrayList<Cat> cats = new ArrayList<Cat>();

Ahora hemos creado una lista para almacenar objetos Cat. Prestar atención:No especificamos el tamaño de ArrayList porque se puede expandir automáticamente. ¿Cómo es esto posible? Fácilmente. Te sorprenderá, pero ArrayList se basa en una matriz normal :) Sí, dentro de ella hay una matriz en la que se almacenan nuestros elementos. Pero ArrayList tiene un mecanismo especial para trabajar con él:

• Cuando esta matriz interna está llena, ArrayList crea una nueva matriz dentro de sí misma. Su tamaño = (tamaño de la matriz anterior * 1,5) +1.
• Todos los datos se copian de la matriz anterior a la nueva.
• El recolector de basura elimina la matriz anterior.

Gracias a este mecanismo, una ArrayList (a diferencia de una matriz) implementa un método para agregar un nuevo elemento. Este es un método add().

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Hipopótamo"));
}

El nuevo elemento se agrega al final de la lista. Ahora no hay riesgo de desbordamiento, por lo que este mecanismo es completamente seguro. Por cierto, ArrayList no sólo puede buscar un objeto por índice, sino también viceversa: ¡puede encontrar el índice de un objeto en ArrayList por referencia al objeto! Para hacer esto, implementa el método indexOf(): Le pasamos un enlace al objeto deseado y indexOf()nos devuelve su índice:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

Conclusión:

0

Así es, el objeto thomasen realidad está almacenado en la celda 0. Las matrices no sólo tienen desventajas, sino también indudables ventajas. Uno de ellos busca un elemento por índice. Dado que apuntamos a un índice, es decir, a una dirección específica en la memoria, dicha búsqueda en matriz es muy rápida. ¡ArrayList en Java también puede hacer esto! Para ello, implementa un método get():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

Conclusión:

Cat{name='Бегемот'}

Además, puedes averiguar fácilmente si una ArrayList contiene un objeto en particular o no. Esto se hace usando el método contains():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.remove(pushok);
   System.out.println(cats.contains(pushok));
}

El método comprueba si el elemento está contenido en la matriz interna de ArrayList y devuelve el resultado en el formato boolean- trueo false. Conclusión:

false

Y otra cosa importante sobre la inserción. ArrayList le permite insertar datos no solo al final de la matriz, sino también en cualquier celda por índice. Tiene dos métodos para esto:

• add(int index, Cat element)
• set(int index, Cat element)

A ambos, les pasa el índice de la celda en la que desea insertar y un enlace al objeto en sí. La diferencia es que al pegar set()se sobrescribe el valor anterior almacenado en la celda. E insertar add()primero desplaza todos los elementos desde [index]hasta el final de la matriz y agrega el objeto que necesita a la celda vacía resultante. He aquí un ejemplo:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, philipp);//Ahora tenemos una lista de 2 gatos. Agregamos la 3ra via set:

   System.out.println(cats.toString());
}

Conclusión:

[[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фoпп Маркович'}, Cat{name='Бегемот'}]

Teníamos una lista de 2 gatos, insertamos otro a través del método set()en la celda 0. Como resultado, el valor antiguo almacenado en esta celda fue reemplazado por uno nuevo.

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, philipp);//Ahora tenemos una lista de 2 gatos. Agregue el tercero a través de agregar

   System.out.println(cats.toString());
}

Pero add()funcionó de manera diferente. Movió todos los elementos hacia la derecha y luego escribió el nuevo valor en la celda 0. Conclusión:

[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фoпп Маркович'}, Cat{name='Томас'}, Cat{name='Бегемот'}]

Para borrar completamente la lista, utilice el método clear():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.clear();

   System.out.println(cats.toString());
}

Conclusión:

[]

Todo el contenido ha sido eliminado de la lista. Por cierto, preste atención: a diferencia de las matrices, en ArrayList el método toString() se anula e inmediatamente muestra la lista en formato de cadena. En el caso de los arrays, tuvimos que utilizar la clase Arrays para ello. Y ya que nos acordamos de los Arrays: en Java puedes “cambiar” fácilmente entre un array y un ArrayList, es decir, convertir uno en otro. La clase Arrays tiene un método para esto, Arrays.asList(). Con su ayuda, obtenemos el contenido de la matriz como una lista y la pasamos al constructor de nuestra ArrayList:

public static void main(String[] args) {

   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   Cat[] catsArray = {thomas, behemoth, philipp, pushok};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

Conclusión:

[Cat{name='Томас'}, Cat{name='Бегемот'}, Cat{name='Фoпп Маркович'}, Cat{name='Пушок'}]

Puedes hacer lo contrario: obtener una matriz de un objeto ArrayList. Para hacer esto, use el método toArray():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

Tenga en cuenta: pasamos una matriz vacía al método toArray(). No es un error. Dentro de la clase ArrayList, este método se implementa de tal manera que pasar una matriz vacía aumenta su rendimiento. Por ahora, recuerda esto para el futuro (pero también puedes transferir un tamaño específico, funcionará). Hablando de tamaño. El tamaño actual de la lista se puede encontrar usando el método size():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

Es importante entender aquí que, a diferencia de la lengthpropiedad de matriz, el método ArrayList.size() devuelve exactamente el número de elementos, y no la capacidad inicial, porque no la especificamos al crear ArrayList. Por cierto, en general es posible indicarlo. ArrayList tiene un constructor correspondiente. Pero su comportamiento en cuanto a añadir nuevos elementos no cambiará:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);//crear un ArrayList con una capacidad inicial de 2


   Cat thomas = new Cat("Tomás");
   Cat behemoth = new Cat("Hipopótamo");
   Cat philipp = new Cat("Felipe Markovich");
   Cat pushok = new Cat("Pelusa");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

Salida de consola:

4

Creamos una lista con 2 elementos, pero cuando la necesitábamos, se expandió fácilmente. Otra cosa es que si inicialmente creamos una lista muy pequeña, habrá que realizar la operación de expansión con más frecuencia, y esto consume cierta cantidad de recursos. En esta conferencia, apenas tocamos el proceso de eliminar elementos de una ArrayList. Por supuesto, esto no se debe al olvido. Este tema se ha separado en una conferencia separada, que puedes leer más :)