Tabla de contenido
Introducción a otros métodos comunes de LinkedList
La diferencia entre ArrayList y LinkedList
¿Qué es la lista enlazada?
La capa inferior de LinkList es una estructura de lista doblemente vinculada . Dado que la lista vinculada no almacena elementos en un espacio continuo, los elementos se almacenan en nodos separados y luego los nodos se conectan a través de referencias. Por lo tanto, al insertar o eliminar elementos en en cualquier posición, no es necesario mover elementos es más eficiente .
En el marco de la colección, LinkedList también implementa la interfaz List.
ilustrar:
1.LinkedList implementa la interfaz Lista
2. La capa inferior de LinkedList implementa una lista doblemente enlazada.
3.LinkedList no implementa la interfaz RandomAccess, por lo que LinkedList no admite el acceso aleatorio.
4. Insertar y eliminar elementos en cualquier posición en LinkedList es relativamente eficiente y la complejidad del tiempo es O (1)
5.LinkedList es más adecuado para escenarios de inserción en cualquier ubicación
Uso de lista enlazada
Construcción de LinkedList
| método | explicar |
| Lista enlazada() | Construcción sin argumentos |
| Lista enlazada pública (Colección <? extiende E> c) | Construya una lista usando elementos de otros contenedores de colección |
Por ejemplo:
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Test {
public static void main(String[] args) {
//构造一个空的LinkedList
List<Integer> list1 = new LinkedList<>();
//构建一个ArrayList数组，并添加元素
List<String> list2 = new ArrayList<>();
list2.add("JavaSE");
list2.add("JavaWeb");
list2.add("JavaEE");
//使用ArrayList构造LinkedList
List<String> list3 = new LinkedList<>(list2);
}
}Introducción a otros métodos comunes de LinkedList
| método | explicar |
| suma booleana (E e) | Elemento de inserción final e |
| agregar vacío (índice int, elemento E) | Inserte e en la posición del índice |
| booleano addAll(Colección<? extiende E> c) | Insertar elementos en c al final. |
| E eliminar (índice int) | Eliminar el elemento en la posición del índice. |
| booleano eliminar (Objeto o) | Eliminar el primer o encontrado |
| E obtener (índice int) | Obtener el elemento en la posición del índice de subíndice |
| Conjunto E (índice int, elemento E) | Establecer el elemento cuyo subíndice es índice del elemento |
| vacío claro() | Claro |
| booleano contiene (Objeto o) | Determinar si o está en la tabla lineal. |
| int indexOf(Objeto o) | Devuelve el subíndice donde se encuentra la primera o. |
| int último índice de (objeto o) | Encuentre la posición de la primera o de atrás hacia adelante y devuelva su subíndice |
| Lista<E> subLista(int fromIndex, int toIndex) | Interceptar parte de la lista. |
import java.util.LinkedList;
import java.util.List;
public class Test {
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1);//add(elem)表示尾插
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
System.out.println(list.size());//7
System.out.println(list);//1 2 3 4 5 6 7
//在起始位置插入零
list.add(0, 0);//add(elem):在index位置插入elem
System.out.println(list);//0 1 2 3 4 5 6 7
list.remove();//remove():删除第一个元素，内部调用的是removeFirst()
list.removeFirst();//removeFirst():删除第一个元素
list.removeLast();//removeLast():删除最后一个元素
list.remove(1);//remove(index):删除index位置的元素
System.out.println(list);//2 4 5 6
//contains(elem):检测elem元素是否存在，如果存在返回true,否则返回false
if(!list.contains(1)) {
list.add(0, 1);
}
list.add(1);
System.out.println(list);//1 2 4 5 6 1
System.out.println(list.indexOf(1));//indexOf(elem):从前往后找到第一个elem的位置
//0
System.out.println(list.lastIndexOf(1));//lastIndexOf(elem):从后向前找第一个1的位置
//5
int elem = list.get(0);
list.set(0, 100);//将index位置的元素设置为elem
System.out.println(list);//100 2 4 5 6 1
//subList(from, to):用list中的(from, to)之间的元素构造一个新的LinkedList返回
List<Integer> copy = list.subList(0,3);
System.out.println(list);
System.out.println(copy);//100 2 4:注意java中是左闭右开的，所以不包含序号为三的结点
list.clear();//将list中的元素清空
System.out.println(list.size());//0
}
}
Recorrido de LinkedList
import java.util.LinkedList;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
System.out.println(list.size());
//foreach遍历
for(int e : list) {
System.out.print(e + " ");
}
System.out.println();
//使用迭代器进行遍历-正向遍历
ListIterator<Integer> it = list.listIterator();
while(it.hasNext()) {
System.out.print(it.next() + " ");
}
System.out.println();
//使用反向迭代器-反向遍历
ListIterator<Integer> rit = list.listIterator(list.size());
while(rit.hasPrevious()) {
System.out.print(rit.previous() + " ");
}
System.out.println();
}
}
Suplemento: se utiliza el iterador.
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorTest {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
//添加元素到集合中
Iterator<String> iterator = list.listIterator();
while(iterator.hasNext()) {
String element = iterator.next();
//处理元素
}
iterator.remove();
}
}
manual
1. Obtenga el objeto iterador de la colección: obtenga el objeto iterador llamando al método iterador de la colección. Por ejemplo, para la colección ArrayList, puede utilizar el método iterador() para obtener el objeto iterador.
2. Recorre los elementos de la colección: recorre los elementos de la colección utilizando los métodos hasNext() y next() del iterador. El método hasNext() se utiliza para comprobar si hay un elemento siguiente y el método next() se utiliza para obtener el valor del siguiente elemento.
La diferencia entre ArrayList y LinkedList
| diferencia | Lista de arreglo | Lista enlazada |
| En espacio de almacenamiento | debe ser físicamente continuo | Lógicamente continuo, pero no necesariamente físicamente continuo |
| acceso aleatorio | Soporte O(1) | O(N) no es compatible |
| tapón de cabeza | Necesidad de mover elementos, baja eficiencia O(N) | Simplemente modifique el puntero de la referencia, la complejidad del tiempo es O (1) |
| insertar | Cuando el espacio es insuficiente, se requiere expansión | Sin concepto de capacidad |
| Escenarios de aplicación | Almacenamiento eficiente de elementos + acceso frecuente | Inserción y eliminación frecuentes en cualquier ubicación |