LinkedList (Lista enlazada) en Java

En este tutorial, vamos a aprender en detalle la clase LinkedList mediante muchos ejemplos.

La clase LinkedList de la estructura de datos de Java Collection proporciona las funciones de estructura de datos de lista.

Interfaz implementada por LinkedList

• Java interfaz List

• Interfaz Queue de Java

• Java interfaz Deque

Implementación de LinkedList en Java

La clase LinkedList de Java proporciona una implementación de lista enlazada bidireccional.

Cada elemento de la lista enlazada se llamanodos. Contiene3campos:

• Prev - almacenar la dirección del elemento anterior en la lista. El primer elemento es null.

• Next - almacenar la dirección del siguiente elemento en la lista. El último elemento es null.

• Data - almacenar datos reales.

Los elementos de la lista enlazada no se almacenan en orden. Por el contrario, están dispersos y conectados por enlaces (Prev y Next).

Aquí, la lista enlazada contiene3elemento.

• Dog - El primer elemento colocará null como la dirección anterior y la dirección de Cat como la siguiente dirección

• Cat - El segundo elemento colocará la dirección de Dog como la dirección anterior y la dirección de Cow como la siguiente dirección

• Cow - El último elemento colocará la dirección de Cat como la dirección anterior y null como el siguiente elemento

Crear una LinkedList

Esta es la forma en que creamos una lista enlazada en Java:

LinkedList<Type> linkedList = new LinkedList<>();

Aquí, Type representa el tipo de la lista enlazada. Por ejemplo,

//Crear una lista enlazada de tipo entero
LinkedList<Integer> linkedList = new LinkedList<>();
//Crear una lista enlazada de tipo cadena
LinkedList<String> linkedList = new LinkedList<>();

Crear LinkedList utilizando interfaces

Vamos a dar un ejemplo.

List<String> animals1　= new LinkedList<>();

Aquí, declaramos una lista enlazada animals utilizando la interfaz List1La lista enlazada solo puede acceder a los métodos de la interfaz List.

Vamos a dar otro ejemplo.

Queue<String> animals2　= new LinkedList<>();
Deque<String> animals3　= new LinkedList<>();

Aquí, animal2puede acceder a los métodos de la interfaz Queue.

Sin embargo, animal3Sólo se pueden acceder a los métodos de las interfaces Deque y Queue. Esto se debe a que Deque es una subinterface de Queue.

Métodos de LinkedList

LinkedList proporciona varios métodos que nos permiten realizar diferentes operaciones en la lista enlazada.

Agregar elementos a LinkedList

1. Agregar elementos:}Usar el método add()

Para agregar un elemento (nodo) al final de la lista enlazada, usamos el método add(). Por ejemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a LinkedList
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Cat, Horse]

2. Agregar elementos: usando el número de índice

También podemos usar el índice para agregar elementos a la lista enlazada. Por ejemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos usando índice
　　　　　　　　animals.add(0,"Dog");
　　　　　　　　animals.add(1,"Cat");
　　　　　　　　animals.add(2,"Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Cat, Horse]

3. Agregar elementos: agregar una lista enlazada a otra

Para agregar todos los elementos de una lista enlazada a otra, usamos el método addAll(). Por ejemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> mammals = new LinkedList<>();
　　　　　　　　mammals.add("Dog");
　　　　　　　　mammals.add("Cat");
　　　　　　　　mammals.add("Horse");
　　　　　　　　System.out.println("Mamíferos: ")　+　mammals);
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Crocodile");
　　　　　　　　//Agregar todos los elementos de mammals a animals
　　　　　　　　animals.addAll(mammals);
　　　　　　　　System.out.println("Animales: ")　+　animals);
　　　　}
}

Resultados de salida

Mamíferos: [Dog, Cat, Horse]
Animales: [Crocodile, Dog, Cat, Horse]

4. Agregar elementos: usar el método listIterator()

También podemos usar el método listsIterator() para agregar elementos a la lista enlazada. Para usarlo, debemos importar el paquete java.util.ListIterator. Por ejemplo,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//创建ListIterator对象
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.add("Dog");
　　　　　　　　listIterate.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Cat]

Acceder a los elementos de LinkedList

1. Acceder a los elementos: usar el método get()

Para acceder a los elementos de la lista enlazada, podemos usar el método get(). Por ejemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Obtener elementos de la lista enlazada
　　　　　　　　String str = animals.get(1);
　　　　　　　　System.out.print("índice1el elemento: "　+　str);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse, Cat]
índice1el elemento en la posición: Horse

2. Acceder a los elementos: usar el método iterator()

Para recorrer los elementos de la lista enlazada, podemos usar el método iterator(). Debemos importar el paquete java.util.Iterator para poder usar este método. Por ejemplo,

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Crear objeto Iterator
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de salida

LinkedList: Dog, Cat, Horse,

Aquí,

• hasNext() - Si existe un elemento siguiente, devuelve true

• next() - Devuelve el elemento siguiente

3.Acceso a elementos: usar el método listIterator()

También podemos usar el método listIterator() para iterar los elementos de la lista enlazada. Para usar este método, debemos importar el paquete java.util.ListIterator.

El método listsIterator() es más adecuado para usar en listas enlazadas. Esto se debe a que el objeto del método listIterator() también puede iterar hacia atrás. Por ejemplo

import java.util.LinkedList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//创建ListIterator对象
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(listIterate.hasNext())　{
　　　　　　　　　　　　System.out.print(listIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//　Recorrer hacia adelante
　　　　　　　　System.out.print("\nLinkedList inversa: ");
　　　　　　　　while(listIterate.hasPrevious())　{
　　　　　　　　　　　　System.out.print(listIterate.previous());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de salida

LinkedList: Dog, Horse, Cat,
LinkedList inversa: Cat, Horse, Dog,

Aquí,

• hasNext() - Si existe un elemento siguiente, devuelve true

• next() - Devuelve el elemento siguiente

• hasPrevious() - Si existe un elemento anterior, devuelve true

• previous() - Devuelve el elemento anterior

Búsqueda de elementos LinkedList

1.Búsqueda de elemento: usar el método contains()

Para buscar si una lista enlazada contiene un elemento específico, usamos el método contains() por ejemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Verificar si Dog está en la lista enlazada
　　　　　　　　if(animals.contains("Dog"))　{
　　　　　　　　　　　　System.out.println("Dog en LinkedList.");
　　　　　　　　}
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse, Cat]
Dog en LinkedList.

2.Búsqueda de elemento: usar el método indexOf()

• indexOf() - Devuelve la posición de la primera aparición del elemento

• lastIndexOf() - Devuelve la posición de la última aparición del elemento

por ejemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//　Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Primera aparición de Dog
　　　　　　　　int index1　= animals.indexOf("Dog");
　　　　　　　　System.out.println("Primera aparición de Dog en la posición: "　+　index1);
　　　　　　　　//Última aparición de Dog
　　　　　　　　int index2　= animals.lastIndexOf("Dog");
　　　　　　　　System.out.println("最后一次出现Dog的索引值:")　+　index2);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse, Cat, Dog]
第一次出现Dog的索引值: 0
最后一次出现Dog的索引值:　3

Nota:如果找不到指定的元素，indexOf()和lastIndexOf()都返回-1。

更改 LinkedList 元素

1.更改元素：使用set()方法

要更改链接列表的元素，我们可以使用set()方法。例如，

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//更改索引值为3del elemento
　　　　　　　　animals.set(3, "Zebra");
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse, Cat, Dog]
新的LinkedList: [Dog, Horse, Cat, Zebra]

2.更改元素：使用listIterator()方法

我们还可以使用listIterator()方法更改链接列表中的元素。例如，

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//　Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//创建ListIterator对象
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//更改由next()返回的元素
　　　　　　　　listIterate.set("Cow");
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Cat, Horse]
新的LinkedList: [Cow, Cat, Horse]

删除LinkedList元素

1.删除元素：使用remove()方法

要从链接列表中删除元素，我们可以使用remove()方法。例如，

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Zebra");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//删除索引值为1del elemento
　　　　　　　　String str = animals.remove(1);
　　　　　　　　System.out.println("删除元素: ")　+　str);
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse, Cat, Zebra]
删除元素: Horse
新的LinkedList: [Dog, Cat, Zebra]

2.删除元素：使用listIterator()方法

我们还可以使用listsIterator()方法从链接列表中删除元素。例如，

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//创建ListIterator对象
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//Eliminar el elemento devuelto por next()
　　　　　　　　listIterate.remove();
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Cat, Horse]
Nueva LinkedList: [Cat, Horse]

3. Eliminar elemento: usando el método clear()

Para eliminar todos los elementos de la lista enlazada, usamos el método clear(). Por ejemplo:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Eliminar todos los elementos
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Cat, Horse]
Nueva LinkedList: []

Nota:También podemos usar el método removeAll() para eliminar todos los elementos. Sin embargo, el método clear() es más eficiente que removeAll().

4. Eliminar elemento: usando el método removeIf()

Si un elemento cumple con una condición específica, también podemos eliminarlos de la lista enlazada. Para esto, usamos el método removeIf(). Por ejemplo:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<Integer> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add(2);
　　　　　　　　animals.add(3);
　　　　　　　　animals.add(4);
　　　　　　　　animals.add(5);
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//　Eliminar todos los elementos menores que4del elemento
　　　　　　　　animals.removeIf((Integer i)->i　4);
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　　　　/**　Aquí usamos una expresión lambda
　　　　　　　*　　Ahora recuerda
　　　　　　　*　　El parámetro de removeIf() es una condición
　　　　　　　*/
　　　　}
}

Resultados de salida

LinkedList: [2,　3,　4,　5]
Nueva LinkedList: [4,　5]

Nota: (Integer i)->i<4 Es una expresión lambda. Para obtener más información sobre las expresiones lambda, visiteExpresiones Lambda de Java

LinkedList como Deque y Queue

Dado que la clase LinkedList también implementa las interfaces Queue y Deque, también puede implementar estos métodos de interfaz. A continuación se presentan algunos métodos comunes:

Métodos addFirst() y addLast()

• addFirst() - Agregar el elemento especificado al principio de la lista enlazada

• addLast() - Agregar el elemento especificado al final de la lista enlazada

por ejemplo,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elemento al principio de LinkedList
　　　　　　　　animals.addFirst("Cow");
　　　　　　　　animals.addFirst("Dog");
　　　　　　　　animals.addFirst("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Agregar elementos al final de LinkedList
　　　　　　　　animals.addLast("Zebra");
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Cat, Dog, Cow]
nueva LinkedList: [Cat, Dog, Cow, Zebra]

métodos getFirst() y getLast()

• getFirst() - devolver el primer elemento

• getLast() - devolver el último elemento

por ejemplo,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//obtener el primer elemento de la lista enlazada
　　　　　　　　String str1　= animals.getFirst();
　　　　　　　　System.out.println("primer elemento: ")　+　str1);
　　　　　　　　//obtener el último elemento de la lista enlazada
　　　　　　　　String str2　= animals.getLast();
　　　　　　　　System.out.println("último elemento: ")　+　str2);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse, Cat]
primer elemento: Dog
último elemento: Cat

métodos removeFirst() y removeLast()

• removeFirst() - eliminar el primer elemento

• removeLast() - eliminar el último elemento

por ejemplo,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//eliminar el primer elemento de LinkedList
　　　　　　　　String str1　= animals.removeFirst();
　　　　　　　　System.out.println("elemento eliminado: ")　+　str1);
　　　　　　　　//eliminar el último elemento de LinkedList
　　　　　　　　String str2　= animals.removeLast();
　　　　　　　　System.out.println("elemento eliminado: ")　+　str2);
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse, Cat]
elemento eliminado: Dog
elemento eliminado: Cat
nueva LinkedList: [Horse]

método peek()

El método peek() devuelve el primer elemento de la lista enlazada (cabecera). Por ejemplo,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//acceder al primer elemento de LinkedList
　　　　　　　　String str = animals.peek();
　　　　　　　　System.out.println("acceso de elementos: ")　+　str);
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse, Cat]
acceso de elementos: Dog
Nueva LinkedList: [Dog, Horse, Cat]

método poll()

El método poll() devuelve y elimina el primer elemento de la lista enlazada. Por ejemplo,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//devolver y eliminar el primer elemento
　　　　　　　　String str = animals.poll();
　　　　　　　　System.out.println("elemento eliminado: ")　+　str);
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse, Cat]
elemento eliminado: Dog
nueva LinkedList: [Horse, Cat]

método offer()

El método offer() añade el elemento especificado al final de la lista enlazada. Por ejemplo,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Agregar elementos a la lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Agregar elementos al final de LinkedList
　　　　　　　　animals.offer("Cat");
　　　　　　　　System.out.println("Nueva LinkedList: " );　+　animals);
　　　　}
}

Resultados de salida

LinkedList: [Dog, Horse]
Nueva LinkedList: [Dog, Horse, Cat]

Recorrer la lista enlazada LinkedList

1.Uso de bucle forEach para recorrer

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Crear una lista enlazada
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Uso de bucle forEach
　　　　　　　　System.out.println("Acceder a elementos de la lista:");
　　　　　　　　for(String animal: animals) {
　　　　　　　　　　　　System.out.print(animal);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de salida

LinkedList: [Vaca, Gato, Perro,]
Acceder a elementos de la lista:
Vaca, Gato, Perro,

2.Uso de bucle for

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Crear una lista enlazada
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Uso de bucle for
　　　　　　　　System.out.println("Acceder a elementos de la lista:");
　　　　　　　　for(int i = 0; i < animals.size(); i++) {
　　　　　　　　　　　　System.out.print(animals.get(i));
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de salida

LinkedList: [Vaca, Gato, Perro,]
Acceder a elementos de la lista:
Vaca, Gato, Perro,

En los dos ejemplos, hemos utilizado un bucle para acceder a los elementos individuales de la lista enlazada.

3.Uso del método iterator()

Podemos usar el método iterator() para acceder a los elementos de la lista enlazada. Para usar este método, debemos importar el paquete java.util.Iterator.

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Crear una lista enlazada
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Uso del método iterator()
　　　　　　　　System.out.println("LinkedList utiliza el método iterator():");
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de salida

LinkedList: [Vaca, Gato, Perro,]
LinkedList utiliza el método iterator():
Vaca, Gato, Perro,

LinkedList y ArrayList

LinkedList y ArrayList implementan el interfaz List del framework Collections. Sin embargo, existen algunas diferencias entre ellos.