Comprensión profunda de la colección List en Java
introducción
La colección List en Java es una estructura de datos de uso común que proporciona una colección de elementos ordenada y repetible. En desarrollo, a menudo necesitamos usar List para almacenar y manipular un conjunto de datos. Este artículo brindará una introducción detallada a las características de la colección List en Java, los métodos de operación comunes y algunas habilidades de uso para ayudar a los lectores a comprender y aplicar mejor la colección List.
Una descripción general de la colección List:
¿Qué es una colección de listas?
En Java, una colección de listas es una estructura de datos de uso común que se utiliza para almacenar un conjunto de elementos ordenados y repetibles. Es parte de Java Collections Framework, ubicado en el paquete java.util.
Las características de Lista: ordenada y repetible.
- Orden: Los elementos de una Lista se almacenan en el orden en que se agregaron, y se puede acceder a cada elemento a través de un índice. Esto significa que cuando iteramos sobre la Lista, los elementos están en el mismo orden en que fueron agregados.
- Repetibilidad: la lista permite almacenar el mismo elemento varias veces. Es decir, se pueden agregar elementos duplicados a la Lista y pueden mantener sus respectivas posiciones y órdenes.
Comparación de lista y matriz.
Clases de implementación de lista común:
- ArrayList: implementación de matriz dinámica, adecuada para operaciones de búsqueda y acceso aleatorio.
- LinkedList: Implementación de lista enlazada, adecuada para operaciones frecuentes de inserción y eliminación.
- Vector: una matriz dinámica segura para subprocesos con peor rendimiento que ArrayList.
Métodos de operación comunes de la colección de listas:
Adición de elementos: uso del método add().
Obtener elementos: uso del método get() e índice.
Eliminación de elementos: método remove() y aplicación de iteradores.
Recorriendo elementos: una comparación de bucles for, iteradores y bucles foreach.
Determinar si existe un elemento: la diferencia entre el método contains() y el método equals().
Clasificación y comparación de colecciones de listas:
- Variabilidad de tamaño:
el tamaño de una matriz se determina cuando se crea y el tamaño no se puede cambiar directamente. Si necesita cambiar el tamaño de la matriz, debe crear una nueva matriz y copiar los elementos en la nueva matriz.
List es una interfaz y hay muchas clases de implementación (como ArrayList, LinkedList, etc.), que tienen tamaños variables. El tamaño de la Lista se puede cambiar agregando, eliminando o reemplazando elementos. - Tipos de datos:
las matrices pueden contener elementos de cualquier tipo, incluidos tipos primitivos y tipos de objetos.
La lista solo puede contener elementos de tipo objeto, no tipos primitivos. Si necesita almacenar tipos básicos, debe usar sus clases contenedoras correspondientes. - Atravesar y acceder a elementos:
las matrices pueden usar índices para acceder directamente a los elementos, y atravesar matrices a través de bucles también es más eficiente.
Se accede a los elementos de la lista y se los recorre a través de iteradores o utilizando índices. Aunque las listas también pueden usar índices, el uso de iteradores es más común que las matrices. - Funcionalidad y flexibilidad:
una matriz es una estructura de datos simple que proporciona métodos básicos de acceso y manipulación, como obtener longitud, copiar, etc. Pero no proporciona funciones avanzadas como adición, eliminación, modificación y consulta integradas.
List es una interfaz que proporciona más métodos de operación, como agregar, eliminar, reemplazar, buscar, etc. Es conveniente insertar, eliminar y buscar elementos. - Gestión de la memoria:
una matriz es un conjunto de elementos almacenados de forma contigua en la memoria. Una vez creados, su tamaño es fijo y no se puede ajustar dinámicamente.
Las listas generalmente se implementan como listas vinculadas o matrices dinámicas cuyo tamaño puede expandirse o contraerse según sea necesario.
En general, si necesita una estructura de datos de mayor rendimiento y tamaño fijo, use matrices. Si necesita una estructura de datos de tamaño variable que proporcione más métodos de manipulación, puede usar List. La elección de qué estructura de datos usar depende de las necesidades específicas y los escenarios de uso.
Lista de clasificación: método Collections.sort() y uso de Comparator.
Colecciones.sort()
En Java, una Lista se puede ordenar usando el método Collections.sort(). Este método ordena los elementos utilizando el orden natural predeterminado. Si los elementos de la Lista son tipos primitivos o tipos de objetos que implementan la interfaz Comparable, deberían admitir la ordenación natural.
El siguiente es un código de muestra para ordenar una Lista usando el método Collections.sort():
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ListSortExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(2);
numbers.add(8);
numbers.add(1);
System.out.println("Before sorting: " + numbers);
Collections.sort(numbers);
System.out.println("After sorting: " + numbers);
}
}
resultado de salida
Antes de clasificar: [5, 2, 8, 1]
Después de clasificar: [1, 2, 5, 8]
Comparación de objetos: el uso de la interfaz Comparable y la interfaz Comparator.
En algunos casos, puede ser necesario utilizar una lógica de clasificación personalizada. Para hacer esto, puede usar la interfaz Comparator para crear un comparador y pasarlo al método Collections.sort(). Los comparadores definen reglas de comparación entre elementos.
El siguiente es un código de ejemplo para la clasificación personalizada usando Comparator:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ListSortExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("John");
names.add("Alice");
names.add("Bob");
names.add("David");
System.out.println("Before sorting: " + names);
// 使用自定义的比较器按照字符串长度排序
Collections.sort(names, new LengthComparator());
System.out.println("After sorting: " + names);
}
// 自定义比较器
static class LengthComparator implements Comparator<String> {
@Override
public int compare(String s1, String s2) {
return Integer.compare(s1.length(), s2.length());
}
}
}
resultado de salida
Antes de clasificar: [John, Alice, Bob, David]
Después de clasificar: [Bob, John, Alice, David]
En el ejemplo anterior, el Comparador de longitud se usa para personalizar el comparador para ordenar los elementos según la longitud de la cadena.
Al usar Comparator, podemos ordenar de manera flexible los elementos de la Lista de acuerdo con nuestras propias necesidades.
Optimización del rendimiento y precauciones para las colecciones de listas:
Inicializar la capacidad de Lista
Al inicializar una Lista, puede especificar opcionalmente su capacidad inicial. La capacidad inicial se refiere al tamaño del arreglo interno asignado por la Lista cuando se crea. La especificación de una capacidad inicial adecuada puede mejorar el rendimiento al evitar operaciones frecuentes de copia y reasignación de matrices internas.
Para situaciones en las que se conoce o estima el número de elementos que se almacenarán, se puede seleccionar una capacidad inicial razonable en función de la experiencia. En general, las siguientes reglas se pueden utilizar como referencia:
Si se conoce el número de elementos, la capacidad inicial se puede especificar directamente en función del número. Por ejemplo, si sabe que List contendrá 100 elementos, puede usar new ArrayList<>(100) para inicializar un ArrayList con una capacidad de 100.
Si el número de elementos es incierto, pero se estima aproximadamente un rango de números, se puede elegir una capacidad inicial cercana a ese rango. Por ejemplo, si el número estimado de elementos está entre 100 y 1000, puede elegir new ArrayList<>(500).
Si la cantidad de elementos es completamente incierta, puede elegir una capacidad inicial pequeña, como 10 o 20. List expandirá automáticamente la capacidad según sea necesario, por lo que una pequeña capacidad inicial no causará problemas de rendimiento, pero ahorrará algo de espacio en la memoria.
Cabe señalar que la capacidad inicial no limita el tamaño de la Lista, y la Lista puede crecer dinámicamente. Si la capacidad inicial no es suficiente para acomodar los elementos agregados, List aumentará automáticamente la capacidad para acomodar más elementos.
En definitiva, la elección de una capacidad inicial adecuada depende de la estimación del número de elementos y de las necesidades de la aplicación. Para equilibrar el rendimiento y el consumo de memoria, puede elegir una capacidad inicial adecuada según la situación real. Si la capacidad inicial es demasiado pequeña, es posible que se produzcan operaciones frecuentes de reasignación de matrices internas y, si la capacidad inicial es demasiado grande, es posible que se desperdicie la memoria.
Use Iterator para recorrer la colección
En Java, iterar sobre una Lista usando un Iterador es una práctica común por varias razones:
Método de recorrido unificado: el uso de Iterator puede proporcionar una forma unificada de recorrer diferentes tipos de List, ya sea ArrayList, LinkedList u otras clases que implementan la interfaz de List, puede usar el mismo método de recorrido para hacer que el código sea más consistente y legible.
Compatibilidad con modificaciones concurrentes: Iterator proporciona compatibilidad con modificaciones concurrentes seguras. En el proceso de atravesar la Lista usando Iterator, si otros subprocesos modifican la Lista, no se generará ConcurrentModificationException. Esto se debe a que Iterator mantendrá un contador de modificaciones durante el proceso transversal. Cuando se modifica la Lista, verificará si el valor del contador es consistente y, de no ser así, se lanzará una excepción.
Los elementos se pueden eliminar: el iterador proporciona el método remove(), que puede eliminar de forma segura el elemento iterado actualmente durante el recorrido sin destruir el estado del recorrido. Esta es una característica que el método remove() de la interfaz List no tiene.
El siguiente es un código de muestra para recorrer una Lista usando Iterator:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListIteratorExample {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");
Iterator<String> iterator = fruits.iterator();
while (iterator.hasNext()) {
String fruit = iterator.next();
System.out.println(fruit);
}
}
}
Evite las operaciones frecuentes de inserción y eliminación.
En Java, el rendimiento de las clases de implementación de List (como ArrayList y LinkedList) para operaciones frecuentes de inserción y eliminación puede variar, pero generalmente se recomienda evitar operaciones frecuentes de inserción y eliminación, especialmente en grandes conjuntos de datos. Aquí hay algunas razones:
-
Sobrecarga de memoria y rendimiento: las operaciones de inserción y eliminación pueden implicar la reasignación y copia de matrices internas o listas vinculadas. Estas operaciones pueden dar como resultado una gran cantidad de operaciones de copia y asignación de memoria, lo que genera una sobrecarga de memoria y rendimiento adicional.
-
Complejidad de tiempo: en ArrayList, las operaciones de inserción y eliminación implican el movimiento hacia adelante y hacia atrás de los elementos, lo que da como resultado una complejidad de tiempo promedio de O(n). En LinkedList, la complejidad de tiempo promedio de las operaciones de inserción y eliminación es O(1), pero se requiere más sobrecarga de memoria.
-
Coherencia de datos e invalidación de iteradores: las operaciones frecuentes de inserción y eliminación pueden invalidar los iteradores o producir resultados incoherentes. Cuando la Lista se modifica durante el recorrido del iterador, o se realiza una modificación simultánea en un entorno de subprocesos múltiples, pueden producirse excepciones ConcurrentModificationException o resultados indeterminados.
Si necesita operaciones frecuentes de inserción y eliminación, puede considerar usar otras estructuras de datos, como LinkedList. LinkedList funciona mejor para las operaciones de inserción y eliminación porque se implementa en función de una lista vinculada. Pero ArrayList suele ser más eficiente cuando se trata de acceso aleatorio y recorrido de elementos.
En las aplicaciones prácticas, es necesario seleccionar una estructura de datos adecuada según las necesidades y los escenarios específicos. Si necesita realizar operaciones frecuentes de inserción y eliminación, puede evaluar las características de rendimiento de diferentes estructuras de datos y elegir la clase de implementación más adecuada para mejorar la eficiencia.
Escenarios de aplicación y casos reales de recogida de listas:
Almacenamiento y procesamiento de datos.
Implementar estructuras de datos como pilas y colas.
Implementar la funcionalidad de búsqueda y filtro.
en conclusión
A través de la introducción de este artículo, tenemos una comprensión más profunda de la colección List en Java. Como estructura de datos de uso común, List tiene las características de orden y repetibilidad, y es adecuada para el almacenamiento y operación de datos en varios escenarios. Dominar los métodos y técnicas comunes de la recopilación de listas puede mejorar la eficiencia del desarrollo y la calidad del código. Espero que este artículo pueda ayudar a los lectores a comprender y aplicar mejor la colección List en Java.