En el artículo anterior, aprendí el uso de la interfaz Collection, y luego aprendí las subclases de la interfaz Collection, las colecciones java.util.List y java.util.Map.
La interfaz java.util.List hereda se extiende desde la interfaz Collection. Es una rama importante de una colección de una sola columna. Los objetos que implementan la interfaz List se denominan habitualmente colección List. Los elementos duplicados están permitidos en la colección List . Todos los elementos se almacenan de manera lineal, se puede acceder al elemento especificado en la colección por índice en el programa. Además, otra característica de la colección List es que los elementos están ordenados , es decir, el orden en el que se almacenan los elementos es el mismo que el orden en que se eliminan.
Lista de características de la interfaz:
1. Es una colección ordenada de acceso a elementos. Por ejemplo, el orden de almacenamiento de los elementos es 11, 22, 33. Luego, en el conjunto, el almacenamiento de los elementos se realiza en el orden de 11, 22, 33.
2. Es una colección con un índice, y los elementos de la colección se pueden manipular con precisión a través del índice (lo mismo que el índice de la matriz).
3. Puede haber elementos repetidos en la colección, y se usa el método igual de los elementos para comparar si son elementos repetidos.
Consejos: He aprendido antes la clase java.util.ArrayList, una subclase de la interfaz List. Los métodos de esta clase están todos definidos en List.
Enumere los métodos comunes:
Nota: Cuando opere el índice, asegúrese de evitar la excepción de índice fuera de límites. (No exceda el rango de índice)
public void add (int index, E element): agrega el elemento especificado a la posición especificada en la colección.
public E get (int index): Devuelve el elemento en la posición especificada en la colección.
public E remove (int index): elimina el elemento en la posición especificada en la lista y devuelve el elemento eliminado.
public E set (int index, E element): Reemplaza el elemento en la posición especificada en el conjunto con el elemento especificado, y el valor de retorno es el elemento antes de la actualización .
public static void main(String[] args) { // 多态写法 List<String> list = new ArrayList<>(); // 按顺序添加元素 list.add("aaa"); list.add("bbb"); list.add("ccc"); // 打印集合 System.out.println(list); // [aaa, bbb, ccc] 重写了toString方法 // 按索引添加元素 // public void add(int index,E element)：将指定的元素，添加到该集合中的指定位置上。 // 在bbb和ccc之间，添加ddd // 注意不是替换，是先将该索引位置的元素及后面的元素后移，而后插入 list.add(2,"ddd"); System.out.println(list); // [aaa, bbb, ddd, ccc] // public E remove(int index)：移除列表中指定位置的元素，返回的是被移除的元素。 // 移除ddd元素，注意，此处后续元素也是有前移动作 String str = list.remove(2); System.out.println("被移除的元素：" + str); // 被移除的元素：ddd System.out.println(list); // [aaa, bbb, ccc] // public E set(int index,E element)： // 用指定元素替换集合中指定位置的元素，返回值是更新前的元素。 // 将aaa替换为AAA String str1 = list.set(0,"AAA"); System.out.println("被替换的元素：" + str1); // 被替换的元素：aaa System.out.println(list); // [AAA, bbb, ccc] // public E get(int index)：返回集合中指定位置的元素。 // List集合遍历有三种方式 // 1.普通的遍历 System.out.println("普通for循环遍历"); for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } // 2.for each遍历 System.out.println("for each循环遍历"); for (String str2 : list) { System.out.println(str2); } // 3.迭代器遍历 System.out.println("迭代器遍历"); Iterator<String> iterator = list.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } }
Lista de subclase (clase de implementación)
1. Colección ArrayList (presentada anteriormente), la estructura de datos correspondiente es: matriz dinámica
ArrayList tiene una alta eficiencia de consulta debido a las direcciones continuas almacenadas. Solo necesita proporcionar un índice. La complejidad de tiempo es O (1), pero agregar y eliminar requiere mover datos, y la complejidad de tiempo llega a O (n). Cuando un gran Se requiere un número de adiciones y eliminaciones en el programa Cuando los datos, la estructura de datos ArrayList no es adecuada para su uso.
2.LinkedList
La estructura del almacenamiento de datos de la colección java.util.LinkedList es una estructura de lista enlazada. Una colección que facilita la adición y eliminación de elementos.
LinkedList es una lista doblemente enlazada.
Características:
1. La capa inferior es una estructura de lista vinculada: la consulta es lenta y la adición y eliminación es rápida.
2. Contiene una gran cantidad de métodos para operar el principio y el final.
Nota: Se utiliza el método único de la colección LinkedList y no se puede utilizar el polimorfismo.
Métodos comunes:
public void addFirst (E e): Agrega el elemento especificado al principio de esta lista.
public void addLast (E e): Agrega el elemento especificado al final de esta lista.
public E getFirst (): Devuelve el primer elemento de esta lista.
public E getLast (): Devuelve el último elemento de esta lista.
public E removeFirst (): Elimina y devuelve el primer elemento de esta lista.
public E removeLast (): Elimina y devuelve el último elemento de esta lista.
public E pop (): saca un elemento de la pila representada por esta lista.
public void push (E e): Inserta el elemento en la pila representada por esta lista.
public boolean isEmpty (): si la lista no contiene elementos, devuelve verdadero.
/* public E removeFirst()：移除并返回此列表的第一个元素。 public E removeLast()：移除并返回此列表的最后一个元素。 public E pop()：从此列表所表示的堆栈处弹出一个元素。 */ private static void show03() { LinkedList<String> linkedList = new LinkedList<>(); linkedList.add("aaa"); linkedList.add("bbb"); linkedList.add("ccc"); // public E removeFirst()：移除并返回此列表的第一个元素。 String removeFirst = linkedList.removeFirst(); System.out.println("被移除的第一个元素：" + removeFirst); // 被移除的第一个元素：aaa System.out.println(linkedList); // [bbb, ccc] // public E removeLast()：移除并返回此列表的最后一个元素。 String removeLast = linkedList.removeLast(); System.out.println("被移除的最后一个元素：" + removeLast); // 被移除的最后一个元素：ccc System.out.println(linkedList); // [bbb] // public E pop()：从此列表所表示的堆栈处弹出一个元素。 // 此方法相当于removeFirst方法 String pop = linkedList.pop(); System.out.println("从栈顶弹出的元素：" + pop); // bbb System.out.println(linkedList); // } // public E getFirst()：返回此列表的第一个元素。 // public E getLast()：返回此列表的最后一个元素。 private static void show02() { LinkedList<String> linkedList = new LinkedList<>(); linkedList.add("aaa"); linkedList.add("bbb"); linkedList.add("ccc"); if(!linkedList.isEmpty()) { String first = linkedList.getFirst(); String last = linkedList.getLast(); System.out.println("第一个元素：" + first); // aaa System.out.println("最后一个元素：" + last); // cc } // 清空 linkedList.clear(); System.out.println(linkedList.size()); // 0 } /* public void addFirst(E e)：将指定元素添加到此列表的开头。 public void addLast(E e)：将指定元素添加到此列表的结尾。 public void push(E e)：将元素推入此列表所表示的堆栈。 */ private static void show01() { // 创建LinkedList集合对象，不能使用多态 LinkedList<String> linkedList = new LinkedList<>(); // 使用add方法往集合中添加元素 linkedList.add("aaa"); linkedList.add("bbb"); linkedList.add("ccc"); // 使用addFirst方法往集合开头添加元素 linkedList.addFirst("AAA"); System.out.println(linkedList); // [AAA, aaa, bbb, ccc] // public void push(E e)：将元素推入此列表所表示的堆栈。 // 等效于addFirst方法 linkedList.push("111"); System.out.println(linkedList); // [111, AAA, aaa, bbb, ccc] // public void addLast(E e)：将指定元素添加到此列表的结尾。 // 此方法等效于add方法 linkedList.addLast("DDD"); System.out.println(linkedList); // [111, AAA, aaa, bbb, ccc, DDD] }
La clase Vector puede implementar una matriz creciente de objetos (la capa inferior es una matriz dinámica como ArrayList), y Vector es sincrónico (de un solo subproceso) y lento.