Lista de matrices de Java es parte de Java marco de colecciones y es una clase del paquete java.util. Nos proporciona matrices dinámicas en Java. Sin embargo, puede ser más lento que los arreglos estándar, pero puede ser útil en programas donde se necesita mucha manipulación en el arreglo. Esta clase se encuentra en java.util paquete. El principal ventaja de ArrayList en Java es decir, si declaramos una matriz entonces necesitamos mencionar el tamaño, pero en ArrayList, no es necesario mencionar el tamaño de ArrayList. Si quieres mencionar el tamaño, puedes hacerlo.

Tabla de contenidos

• ¿Qué es ArrayList en Java?
• Ejemplo de lista de matrices de Java
• Características importantes de ArrayList en Java
• Constructores en ArrayList
• ArrayList en métodos Java
• Operaciones realizadas en ArrayList
• Complejidad de Java ArrayList
• Ventajas de Java ArrayList
• Desventajas de Java ArrayList
• Conclusión
• Preguntas frecuentes sobre ArrayList

¿Qué es ArrayList en Java?

ArrayList es una clase Java implementada mediante la interfaz List. Java ArrayList, como su nombre indica, proporciona la funcionalidad de una matriz dinámica donde el tamaño no está fijo como matriz. Además, como parte del marco de Colecciones, tiene muchas características que no están disponibles con las matrices.

convertir cadena a entero

Ilustración:

Comprobemos ArrayList con el tipo de objeto Integer almacenado en él con una imagen.

Ejemplo de lista de matrices de Java

Ejemplo 1: La siguiente implementación demuestra cómo crear y utilizar un ArrayList con una mención de su tamaño.

// Java program to demonstrate the // working of ArrayList import java.io.*; import java.util.*; class ArrayListExample {  public static void main(String[] args)  {  // Size of the  // ArrayList  int n = 5;  // Declaring the ArrayList with  // initial size n  ArrayList arr1 = nueva lista de matrices (norte);  // Declarando ArrayList ArrayList arr2 = nueva lista de matrices ();  // Imprimiendo ArrayList System.out.println('Array 1:' + arr1);  System.out.println('Matriz 2:' + arr2);  // Agregando nuevos elementos al // final de la lista for (int i = 1; i<= n; i++) {  arr1.add(i);  arr2.add(i);  }  // Printing the ArrayList  System.out.println('Array 1:' + arr1);  System.out.println('Array 2:' + arr2);  } }>

Array 1:[] Array 2:[] Array 1:[1, 2, 3, 4, 5] Array 2:[1, 2, 3, 4, 5]>

Explicación del programa anterior:

ArrayList es una matriz dinámica y no tenemos que especificar el tamaño al crearla; el tamaño de la matriz aumenta automáticamente cuando agregamos y eliminamos elementos dinámicamente. Aunque la implementación real de la biblioteca puede ser más compleja, la siguiente es una idea muy básica que explica el funcionamiento de la matriz cuando se llena y si intentamos agregar un elemento:

• Crea una memoria de mayor tamaño en la memoria del montón (por ejemplo, memoria del doble de tamaño).
• Copia los elementos de la memoria actual a la nueva memoria.
• El nuevo elemento se agrega ahora porque ahora hay más memoria disponible.
• Elimina el recuerdo antiguo.

Características importantes de ArrayList en Java

• ArrayList hereda ResumenLista clase e implementa el Interfaz de lista .
• ArrayList se inicializa por tamaño. Sin embargo, el tamaño aumenta automáticamente si la colección crece o se reduce si la colección objetos son eliminados de la colección.
• Java ArrayList nos permite acceder aleatoriamente a la lista.
• ArrayList no se puede utilizar para clase contenedora para tales casos.
• ArrayList en Java puede verse como un vectores en C++ .
• ArrayList no está sincronizado. Su clase sincronizada equivalente en Java es Vector .

entendamos el Java ArrayList en profundidad . Mira la imagen de abajo:

conectar base de datos java

En la ilustración anterior, ResumenLista , Copiar en escritura Lista de matrices , y ResumenListaSecuencial son las clases que implementan la interfaz de lista. Se implementa una funcionalidad separada en cada una de las clases mencionadas. Ellos son:

1. ResumenLista: Esta clase se utiliza para implementar una lista no modificable, para lo cual solo es necesario extender esta clase AbstractList e implementar solo el conseguir() y el tamaño() métodos.
2. CopiarEnWriteArrayList: Esta clase implementa la interfaz de lista. Es una versión mejorada de Lista de arreglo en el que todas las modificaciones (agregar, configurar, eliminar, etc.) se implementan haciendo una copia nueva de la lista.
3. Lista secuencial abstracta: Esta clase implementa el Interfaz de colección y la clase AbstractCollection. Esta clase se utiliza para implementar una lista no modificable, para lo cual solo es necesario extender esta clase AbstractList e implementar solo el conseguir() y el tamaño() métodos.

Constructores en ArrayList en Java

Para crear una ArrayList, necesitamos crear un objeto de la clase ArrayList. La clase ArrayList consta de varios constructores que permiten la posible creación de la lista de matrices. Los siguientes son los constructores disponibles en esta clase:

1. Lista de matrices ()

Este constructor se utiliza para crear una lista de matrices vacía. Si deseamos crear un ArrayList vacío con el nombre llegar , entonces, se puede crear como:

ArrayList arr = new ArrayList();>

2. ArrayList (Colección c)

Este constructor se utiliza para construir una lista de matrices inicializada con los elementos de la colección c. Supongamos que deseamos crear un arreglo ArrayList que contenga los elementos presentes en la colección c, luego, se puede crear como:

ArrayList arr = new ArrayList(c);>

3. ArrayList (capacidad interna)

Este constructor se utiliza para crear una lista de matrices con la capacidad inicial especificada. Supongamos que deseamos crear un ArrayList con un tamaño inicial N, entonces, se puede crear como:

ArrayList arr = new ArrayList(N);>

Métodos Java ArrayList

Nota: También puedes crear una ArrayList genérica:

// Creando ArrayList entero genérico
ArrayList arrli = nueva ArrayList();

Algunos puntos clave de ArrayList en Java

1. ArrayList es una estructura de datos subrayada, matriz redimensionable o matriz ampliable.
2. Se permiten duplicados de ArrayList.
3. Se conserva el orden de inserción.
4. Se permiten objetos heterogéneos.
5. Es posible la inserción nula.

Veamos cómo realizar algunas operaciones básicas en ArrayList como se enumeran y que discutiremos más a fondo junto con la implementación de cada operación.

• Agregar elemento a la lista/Agregar elemento
• Cambiar elementos/Establecer elemento
• Eliminar elementos/Eliminar elemento
• Elementos iterativos
• obtener elementos
• agregar elementos entre dos números
• Ordenar elementos
• Tamaño de la lista de matrices

Operaciones realizadas en ArrayList

1. Agregar elementos

Para agregar un elemento a un ArrayList, podemos usar el método agregar () . Este método está sobrecargado para realizar múltiples operaciones basadas en diferentes parámetros. Son los siguientes:

• agregar (Objeto): este método se utiliza para agregar un elemento al final de ArrayList.
• add(int index, Object): este método se utiliza para agregar un elemento en un índice específico en ArrayList.

A continuación se muestra la implementación del enfoque anterior:

// Java Program to Add elements to An ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Array of string type  ArrayListal = nueva ListaArray();  // Agregar elementos a ArrayList // Entradas personalizadas al.add('Geeks');  al.add('Geeks');  // Aquí mencionamos el índice // en el que se agregará al.add(1, 'For');  // Imprimiendo todos los elementos en un ArrayList System.out.println(al);  } }>

[Geeks, For, Geeks]>

2. Elementos cambiantes

Después de agregar los elementos, si deseamos cambiar el elemento, podemos hacerlo usando el colocar() método. Dado que un ArrayList está indexado, el índice del elemento hace referencia al elemento que deseamos cambiar. Por lo tanto, este método toma un índice y el elemento actualizado que debe insertarse en ese índice.

A continuación se muestra la implementación del enfoque anterior:

// Java Program to Change elements in ArrayList // Importing all utility classes import java.util.*; // main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist object of string type  ArrayListal = nueva ListaArray();  // Agregar elementos a Arraylist // Elementos de entrada personalizados al.add('Geeks');  al.add('Geeks');  // Agregando especificando el índice que se agregará al.add(1, 'Geeks');  // Imprimiendo los elementos de Arraylist System.out.println('Initial ArrayList ' + al);  // Estableciendo elemento en el primer índice al.set(1, 'For');  // Imprimiendo el Arraylist actualizado System.out.println('Updated ArrayList ' + al);  } }>

Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>

3. Eliminando elementos

Para eliminar un elemento de un ArrayList, podemos usar el método eliminar() . Este método está sobrecargado para realizar múltiples operaciones basadas en diferentes parámetros. Son los siguientes:

• eliminar (Objeto): Este método se utiliza para simplemente eliminar un objeto de ArrayList. Si hay varios objetos de este tipo, se elimina la primera aparición del objeto.
• eliminar (índice int): Dado que un ArrayList está indexado, este método toma un valor entero que simplemente elimina el elemento presente en ese índice específico en ArrayList. Después de eliminar el elemento, todos los elementos se mueven hacia la izquierda para llenar el espacio y se actualizan los índices de los objetos.

Ejemplo:

// Java program to Remove Elements in ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an object of arraylist class  ArrayListal = nueva ListaArray();  // Agregar elementos a ArrayList // Adición personalizada al.add('Geeks');  al.add('Geeks');  // Agregando elemento en un índice específico al.add(1, 'For');  // Imprimiendo todos los elementos de ArrayList System.out.println('Initial ArrayList ' + al);  // Eliminando elemento de arriba ArrayList al.remove(1);  // Imprimiendo los elementos actualizados de Arraylist System.out.println('Después de la eliminación del índice ' + al);  // Eliminando este elemento de palabra en ArrayList al.remove('Geeks');  // Ahora imprimiendo ArrayList actualizado System.out.println('After the Object Removal ' + al);  } }>

Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>

4. Iterando la lista de matrices

Hay varias formas de iterar a través de ArrayList. Las formas más famosas son mediante el uso de lo básico. en bucle en combinación con un método obtener() para obtener el elemento en un índice específico y el avanzado para un bucle .

Ejemplo

orden sql por fecha

// Java program to Iterate the elements // in an ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist of string type  ArrayListal = nueva ListaArray();  // Agregar elementos a ArrayList // usando el método add() estándar al.add('Geeks');  al.add('Geeks');  al.add(1, 'Para');  // Usando el método Get y el // bucle for for (int i = 0; i< al.size(); i++) {  System.out.print(al.get(i) + ' ');  }  System.out.println();  // Using the for each loop  for (String str : al)  System.out.print(str + ' ');  } }>

Geeks For Geeks Geeks For Geeks>

5. Obtener elementos

// Java program to get the elemens in ArrayList import java.io.*; import java.util.*; class GFG {  public static void main (String[] args) {  ArrayList lista = nueva ArrayList();  // agrega el número list.add(9);  lista.add(5);  lista.add(6);  System.out.println(lista);  // obtener método Entero n= list.get(1);  System.out.println('en el índice 1 el número es:'+n);  } }>

[9, 5, 6] at indext 1 number is:5>

6. Suma elementos entre dos números

// Java program to add the elements  // between two numbers in ArrayList import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList lista = nueva ArrayList();  lista.add(1);  lista.add(2);  lista.add(4);  System.out.println(lista);  // inserta el elemento 3 que falta list.add(2, 3);  System.out.println(lista);  } }>

[1, 2, 4] [1, 2, 3, 4]>

7. Ordenación de lista de matrices

// Java Program for ArrayList Sorting import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList lista = nueva ArrayList();  lista.add(2);  lista.add(4);  lista.add(3);  lista.add(1);  System.out.println('Antes de ordenar la lista:');  System.out.println(lista);  Colecciones.sort(lista);  System.out.println('después de ordenar la lista:');  System.out.println(lista);  } }>

Before sorting list: [2, 4, 3, 1] after sorting list: [1, 2, 3, 4]>

8. Tamaño de los elementos

// Java program to find the size  // of elements of an ArrayList import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList lista = nueva ArrayList();  lista.add(1);  lista.add(2);  lista.add(3);  lista.add(4);  int b = lista.tamaño();  System.out.println('El tamaño es:' + b);  } }>

The size is :4>

Complejidad de Java ArrayList

ArrayList en Java es una clase en el marco de Colecciones de Java que implementa la interfaz List. Estas son las ventajas y desventajas de usar ArrayList en Java.

Ventajas de Java ArrayList

1. Tamaño dinámico: ArrayList puede crecer y reducir su tamaño dinámicamente, lo que facilita agregar o eliminar elementos según sea necesario.
2. Fácil de usar: ArrayList es fácil de usar, lo que la convierte en una opción popular para muchos desarrolladores de Java.
3. Acceso rápido: ArrayList proporciona acceso rápido a los elementos, ya que se implementa como una matriz interna.
4. Colección ordenada: ArrayList conserva el orden de los elementos, lo que le permite acceder a los elementos en el orden en que se agregaron.
5. Admite valores nulos: ArrayList puede almacenar valores nulos, lo que lo hace útil en los casos en los que es necesario representar la ausencia de un valor.

Desventajas de Java ArrayList

1. Más lento que las matrices: ArrayList es más lento que las matrices para ciertas operaciones, como insertar elementos en el medio de la lista.
2. Mayor uso de memoria: ArrayList requiere más memoria que las matrices, ya que necesita mantener su tamaño dinámico y manejar el cambio de tamaño.
3. No es seguro para subprocesos: ArrayList no es seguro para subprocesos, lo que significa que varios subprocesos pueden acceder y modificar la lista al mismo tiempo, lo que genera posibles condiciones de carrera y corrupción de datos.
4. Degradación del rendimiento: el rendimiento de ArrayList puede degradarse a medida que aumenta el número de elementos en la lista, especialmente para operaciones como buscar elementos o insertar elementos en el medio de la lista.

Conclusión

Los puntos que deben recordarse de este artículo se mencionan a continuación:

• ArrayList es parte del marco de Colecciones. Hereda la clase AbstractList e implementa la interfaz List.
• ArrayList es la implementación de una matriz dinámica.
• ArrayList se puede inicializar utilizando diferentes tipos de constructores, como sin parámetros, pasando una colección como parámetro y pasando un número entero como parámetro.
• Las operaciones se pueden realizar en ArrayList de la siguiente manera: Agregar, eliminar, iterar y ordenar.

Preguntas frecuentes sobre ArrayList

¿Qué es una ArrayList en Java?

ArrayList en Java es parte del marco de Colecciones. Se utiliza para almacenar elementos y el tamaño se puede cambiar de tamaño.

encapsulación en java

¿Cómo se almacenan los datos en ArrayList?

ArrayList puede almacenar datos hasta que el tamaño de ArrayList esté lleno, después de eso, el tamaño de ArrayList se duplica si queremos almacenar más elementos.

¿ArrayList permite duplicados?

Sí, ArrayList permite almacenar valores duplicados.