La diferencia entre ArrayList y LinkedList
1. ArrayList es una estructura de datos basada en matrices dinámicas y LinkedList es una estructura de datos basada en listas enlazadas.
2. Para acceso aleatorio a get y set, ArrayList es mejor que LinkedList porque LinkedList mueve el puntero.
3. Para operaciones de agregar y eliminar, LinedList es más ventajoso porque ArrayList necesita mover datos.
Esto depende de la situación real. Si solo inserta o elimina un dato, ArrayList es más rápido que LinkedList. Pero si los datos se insertan y eliminan aleatoriamente en lotes, la velocidad de LinkedList es mucho mejor que la de ArrayList, porque cada vez que se inserta un dato en ArrayList, se deben mover todos los datos después del punto de inserción. Hice un experimento sobre esto. Insertar 20.000 datos en la primera posición de ArrayList y LinkedList respectivamente con 200.000 "registros" LinkedList requiere aproximadamente 1 vez más que ArrayList.
for(int m = 0; m & lt20000; m++){
linkedlist.add(m, null); //Al insertar 20000 datos antes de 200000 datos , LinkedList solo toma más de 1125 ms. Ésta es la ventaja de LinkedList.
}
Mucho tiempo 4 = nuevo Dte(). getTime();
system . print(" lista enlazada por lotes:");
system out .
for(int n = 0; n & lt20000; n++){
arraylist.add(n, null); // Al insertar 20.000 datos antes de 200.000 datos, arraylist lo consume tarda más de 18375 ms, que es casi 20 veces más que ArrayList (dependiendo del rendimiento de la máquina durante la prueba).
}
Mucho tiempo 5 = nuevaFecha(). getTime();
System.out.print("Batch ArrayList add:");
system out . p>4. Operaciones de búsqueda, como indexOf, lastIndexOf, contiene, etc. Casi lo mismo.
5. Para la operación de búsqueda aleatoria de un nodo específico, ArrayList es más rápido que LinkedList.
Esto es sólo un análisis teórico. De hecho, si los datos se insertan y eliminan al final, ArrayList debe ser más rápido que LinkedList. Hice un experimento insertando y eliminando 200.000 datos.
Mucho tiempo 1 = nuevaFecha(). getTime();
String s 1 =(String)linked list . get(100000); //El total de registros es 200000 y cargar la lista vinculada requiere 100000 datos, que van de 15 a 32 ms. .
Mucho tiempo 2 = nuevaFecha(). getTime();
system . println(time 2-time 1);
String S2 =(String)ArrayList get(100000); 200000 La lista enlazada tarda 0 ms en cargar el dato número 100.000.
Mucho tiempo 3 = nuevaFecha().
getTime();
system . println(time 3-time 2);
/*Inserte 200000 datos en la lista enlazada y la lista de matrices respectivamente.
* Debido a que los datos se insertan al final, arraylist es más rápido que linkedlist.
*/
lista de inserción vacía estática pública (lista de enlaces de lista vinculada, lista de matrices ArrayList) {
largo tiempo 1 = nuevaFecha(). getTime();
sistema . println(tiempo 1);
for(int I = 0;i<200000;i++) {
lista de enlaces .add (i, "lista de enlaces" + I);
}
mucho tiempo 2 = nuevaFecha(). getTime();
sistema . println(tiempo 2-tiempo 1);
for(int j = 0; j & lt200000;j++) {
arraylist.add(j,"ArrayList"+j);
}
Mucho tiempo 3 = newDate(). getTime();
system . println(time 3-time 2);
}
/* Elimina 200.000 datos en LinkedList y arraylist. .
*Debido a que los datos se eliminan al final, arraylist es más rápido que linkedlist.
*/
lista pública de eliminación de vacíos estáticos (lista de enlaces de lista vinculada, lista de matrices ArrayList) {
largo tiempo 1 = nuevaFecha(). getTime();
sistema . println(hora 1);
for(int I = 199999;i>= 0;i-) {
lista de enlaces .remove(I);
}
Mucho tiempo 2 = newDate(). getTime();
sistema . println(tiempo 2-tiempo 1);
for(int j = 199999; j & gt= 0;j - ) {
ArrayList . remove(j);
}
Mucho tiempo 3 = nuevaFecha(). getTime();
sistema . println(tiempo 3-tiempo 2);
}
Public static void main(String args[]) {
lista enlazada lista enlazada = nueva lista enlazada();
ArrayList ArrayList = nueva ArrayList();
insertList(lista enlazada, ArrayList);
//Se omite el siguiente código.
Inserción:
Lista enlazada 578 milisegundos
Lista de matriz 437 milisegundos
Eliminación:
lista enlazada 31 Milisegundos
Lista de matrices 16 ms