[Conceptos básicos de Java] Guía de uso de listas de Java: análisis en profundidad de las operaciones de listas

Insertar descripción de la imagen aquí

Java es un poderoso lenguaje de programación con un rico conjunto de estructuras de datos y clases de colección, una de las cuales es Listla lista. ListEs una interfaz importante en el marco de colección de Java, que nos permite almacenar un conjunto de elementos de manera ordenada y repetible. ListEste blog irá de básico a avanzado, presentando en detalle interfaces y Listclases de implementación comunes en Java para ayudar a los principiantes a comprender profundamente el concepto, el uso y los escenarios de aplicación de las listas.

¿Qué es una lista?

En Java, Listes una interfaz que hereda de Collectionla interfaz. ListLa interfaz representa una secuencia ordenada de elementos, lo que permite la duplicación de elementos. Esto significa que puede almacenar un conjunto de elementos en el orden en que se agregaron y permitir que el mismo elemento aparezca varias veces. ListLa interfaz proporciona muchos métodos para operar elementos en la lista, incluidos agregar, eliminar, obtener, buscar, etc.

Métodos básicos de la interfaz de lista.

Primero comprendamos Listalgunos métodos básicos en la interfaz:

Agregar elementos : puede add()agregar elementos al final de la lista usando el método. Por ejemplo:

List<String> fruits = new ArrayList<>();
fruits.add("苹果");
fruits.add("香蕉");
fruits.add("橙子");

Obtener elementos : utilice get()el método para obtener elementos en la lista según el índice. Los índices comienzan a contar desde 0, indicando el primer elemento. Por ejemplo:
```
String firstFruit = fruits.get(0); // 获取第一个元素（苹果）
```
Eliminar elementos : utilice remove()el método para eliminar elementos de una lista según el índice o el valor del elemento. Por ejemplo:
```
fruits.remove(1); // 删除索引为 1 的元素（香蕉）
fruits.remove("橙子"); // 删除值为 "橙子" 的元素
```
Obtener el tamaño de la lista : utilice size()el método para obtener la cantidad de elementos de la lista. Por ejemplo:
```
int size = fruits.size(); // 获取列表大小，此时 size 为 2
```
Atravesar una lista : puede utilizar un bucle o un iterador para iterar sobre los elementos de una lista. Por ejemplo:
```
for (String fruit : fruits) {
      
      
    System.out.println(fruit);
}
```

Clases de implementación comunes de Lista

Java proporciona múltiples clases que implementan Listinterfaces, cada una con sus propias características y usos. A continuación se muestran algunas Listclases de implementación comunes:

ArrayList : ArrayListes una matriz dinámica basada en la implementación de una matriz, que admite un acceso aleatorio rápido a los elementos. Si necesita insertar y eliminar elementos con frecuencia, puede elegir otra implementación.
LinkedList : LinkedListEs una lista basada en una lista doblemente enlazada, adecuada para situaciones donde se requieren operaciones frecuentes de inserción y eliminación. Sus operaciones de inserción y eliminación son ArrayListmás rápidas que .
Vector : Vectorsimilar ArrayList, pero seguro para subprocesos. Considere la posibilidad de utilizar listas si las utiliza en un entorno de subprocesos múltiples Vector.
Pila : Stackes una clase heredada Vectory representa la estructura de datos de la pila, que admite operaciones push y pop.

ArrayList frente a LinkedList

ArrayListy LinkedListson dos implementaciones de listas comunes, tienen diferentes características y escenarios aplicables:

ArrayList es adecuado para situaciones en las que se requiere acceso aleatorio frecuente a elementos. Dado que se implementa en una matriz, se puede acceder rápidamente a cualquier elemento de la lista. Sin embargo, las operaciones de inserción y eliminación pueden ser LinkedListmás lentas que .
LinkedList es adecuado para situaciones donde se requieren operaciones frecuentes de inserción y eliminación. Dado que se implementa en base a una lista vinculada, las operaciones de inserción y eliminación suelen ser ArrayListmás rápidas que . Sin embargo, el acceso aleatorio a los elementos puede ser más lento porque es necesario recorrer la lista vinculada para encontrar el elemento.

A continuación profundizaremos en las diferencias y los escenarios aplicables de estas dos implementaciones de listas.

Lista de arreglo

Ventajas :
- Acceso aleatorio rápido: Al estar basado en matrices, ArrayListadmite acceso rápido a elementos por índice. Esto hace que las operaciones de lectura sean muy eficientes.
Escenarios aplicables :
- ArrayListUna mejor opción cuando se requieren operaciones de lectura frecuentes (acceder a elementos a través de índices) .
- ArrayListFunciona mejor cuando el tamaño de la lista es relativamente estable o fijo .

Ejemplo :

List<String> arrayList = new ArrayList<>();
arrayList.add("苹果");
arrayList.add("香蕉");
arrayList.add("橙子");

String fruit = arrayList.get(1); // 快速访问第二个元素

Lista enlazada

Ventajas :
- Inserción y eliminación rápida: debido a que se basa en una lista vinculada, LinkedListadmite la inserción y eliminación rápida de elementos en cualquier posición. Esto hace que las operaciones de edición sean muy eficientes.
Escenarios aplicables :
- LinkedListEs una mejor opción cuando se requieren operaciones frecuentes de inserción y eliminación .
- Funciona mejor cuando el tamaño de la lista puede cambiar dinámicamente LinkedList.

Ejemplo :

List<String> linkedList = new LinkedList<>();
linkedList.add("苹果");
linkedList.add("香蕉");
linkedList.add("橙子");

linkedList.add(1, "葡萄"); // 在第二个位置插入元素
linkedList.remove(0); // 移除第一个元素

Lista transversal

Iterar Listsobre los elementos es una operación común. Puede utilizar diferentes métodos para implementar el recorrido. A continuación se muestran algunos de los más comunes:

1. Utilice bucle para cada

Utilice el bucle for-each mejorado para iterar cómodamente sobre Listlos elementos en:

List<String> fruits = new ArrayList<>();
fruits.add("苹果");
fruits.add("香蕉");
fruits.add("橙子");

for (String fruit : fruits) {
    
    
    System.out.println(fruit);
}

2. Utilice el clásico bucle for.

Puede utilizar un bucle for tradicional para iterar por índice List:

for (int i = 0; i < fruits.size(); i++) {
    
    
    String fruit = fruits.get(i);
    System.out.println(fruit);
}

3. Utilice iteradores

Los iteradores son una forma más general de recorrer y son aplicables a todas Listlas implementaciones. Aquí hay un ejemplo de recorrido usando un iterador:

Iterator<String> iterator = fruits.iterator();
while (iterator.hasNext()) {
    
    
    String fruit = iterator.next();
    System.out.println(fruit);
}

Otras operaciones comunes en la Lista

Además de las operaciones básicas de agregar, eliminar, obtener y recorrer, Listtambién admite muchas otras operaciones comunes, como determinar si la lista está vacía, buscar elementos, invertir la lista, etc. A continuación se muestran algunos métodos utilizados habitualmente:

Determine si la lista está vacía :

boolean isEmpty = fruits.isEmpty(); // 返回 true，如果列表为空

Encuentra el índice de un elemento :

int index = fruits.indexOf("香蕉"); // 返回元素 "香蕉" 的索引，如果不存在则返回 -1

Invertir la lista :

Collections.reverse(fruits); // 反转列表中的元素顺序

Obtener sublista :

List<String> subList = fruits.subList(1, 3); // 获取索引 1 到 2 之间的子列表

Reemplazar elementos :

fruits.set(0, "葡萄"); // 将第一个元素替换为 "葡萄"

Estos métodos pueden ayudarle a manipular elementos de la lista de forma más flexible.

Notas sobre el uso de Lista

Cuando se utiliza en Java List, existen algunas consideraciones y mejores prácticas para garantizar que su código sea eficiente, legible y esté libre de problemas potenciales. Aquí hay algunas Listnotas de uso:

Elija la Listclase de implementación adecuada : Elija la clase de implementación adecuada según sus necesidades List. Si necesita acceso aleatorio frecuente a elementos, elija ArrayList; si necesita operaciones frecuentes de inserción y eliminación, elija LinkedList.
Utilice genéricos : declare siempre el uso de genéricos Listpara garantizar la seguridad de tipos. Por ejemplo, List<String>represente una lista que solo puede almacenar cadenas.

Evite modificar la lista en un bucle : cuando utilice for-eachun bucle para iterar sobre una lista, no modifique el contenido de la lista en el bucle, lo que puede provocar un comportamiento impredecible. Si es necesario realizar modificaciones, utilice un iterador.

// 不推荐的做法，可能会导致 ConcurrentModificationException
for (String fruit : fruits) {
      
      
    if (fruit.equals("橙子")) {
      
      
        fruits.remove(fruit);
    }
}

// 推荐的做法，使用迭代器
Iterator<String> iterator = fruits.iterator();
while (iterator.hasNext()) {
      
      
    String fruit = iterator.next();
    if (fruit.equals("橙子")) {
      
      
        iterator.remove();
    }
}

Nota sobre los valores nulos : Listse permite almacenar valores nulos, pero deben manejarse con cuidado para evitar generar una excepción de puntero nulo en operaciones posteriores.
Considere la concurrencia : si su lista necesita usarse en un entorno de subprocesos múltiples, considere usar una Listclase de implementación segura para subprocesos, como Vectoro Collections.synchronizedList()empaquetar su lista con .
Optimización del rendimiento : si necesita insertar y eliminar una gran cantidad de elementos con frecuencia, considere usarlo LinkedList, tiene mejor rendimiento en este sentido. Y para una gran cantidad de operaciones de lectura, ArrayListes más eficiente.
Evite el boxeo y unboxing innecesarios : cuando utilice tipos de datos básicos (como int), evite empaquetarlos en clases contenedoras (como Integer) para reducir el consumo de memoria y las penalizaciones de rendimiento.
Establezca la capacidad adecuadamente : si conoce el tamaño aproximado de la lista, puede ArrayListespecificar la capacidad inicial al crearla para reducir la expansión dinámica posterior.
```
List<String> fruits = new ArrayList<>(100); // 指定初始容量为 100
```
Utilice Collections.unmodifiableList()listas protegidas : si necesita pasar una lista a otro código, pero no desea que se modifique, puede utilizarla para Collections.unmodifiableList()crear una lista no modificable.
```
List<String> readOnlyList = Collections.unmodifiableList(fruits);
```
Documentación y comentarios : agregue comentarios de documentación a su código que describan el propósito, las características y el comportamiento esperado de la lista para que otros desarrolladores puedan usarla correctamente.

Seguir estas consideraciones le ayudará a gestionarlo y utilizarlo mejor List, mejorando así la calidad y la capacidad de mantenimiento de su código. Recuerde, comprender los conceptos básicos y las mejores prácticas de las listas es importante para escribir código Java eficiente.

Resumir

La interfaz de Java Listes una poderosa herramienta para trabajar con colecciones de elementos ordenadas y repetibles. Diferentes Listimplementaciones son adecuadas para diferentes escenarios y puede elegir la clase de implementación adecuada según sus necesidades. Comprender Listlos métodos básicos, los métodos transversales y las operaciones comunes de la interfaz le ayudará a utilizar mejor las listas para resolver problemas. Con práctica y práctica, dominará el uso de listas y gradualmente obtendrá una comprensión más profunda de las operaciones más avanzadas y las mejores prácticas. Espero que este blog pueda ayudarte a dominar Listlos conocimientos básicos de Java y sentirte más cómodo en la programación.