LinkedList (Lista Encadeada) do Java

Neste tutorial, vamos entender em detalhes a classe LinkedList por meio de muitos exemplos.

A classe LinkedList do Java no framework de coleções do Java fornece funcionalidades de estrutura de dados de lista encadeada.

Interface implementada por LinkedList

• Interface Java List

• Interface Queue do Java

• Interface Java Deque

Implementação de LinkedList no Java

A classe LinkedList do Java fornece uma implementação de lista encadeada bidirecional.

Cada elemento da lista encadeada é chamado denó. Ele contém3de campos:

• Prev - Armazenar o endereço do elemento anterior na lista. O primeiro elemento é null.

• Next - Armazenar o endereço do próximo elemento na lista. O último elemento é null.

• Data - Armazenar dados reais.

Os elementos da lista encadeada não são armazenados em ordem. Em vez disso, eles estão dispersos e conectados por links (Prev e Next).

Aqui, a lista encadeada contém3de elementos.

• Dog - O primeiro elemento usará null como o endereço anterior e o endereço de Cat como o próximo endereço

• Cat - O segundo elemento usará o endereço de Dog como o endereço anterior e o endereço de Cow como o próximo endereço

• Cow - O último elemento usará o endereço de Cat como o endereço anterior e null como o próximo elemento

Criar uma LinkedList

Esta é a maneira como criamos uma LinkedList em Java:

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

Aqui, Type representa o tipo da lista encadeada. Por exemplo,

//Criar uma lista encadeada de tipo inteiro
LinkedList<Integer> linkedList = new LinkedList<>();
//Criar uma lista encadeada de tipo de string
LinkedList<String> linkedList = new LinkedList<>();

Criar LinkedList usando interface

Vamos dar um exemplo.

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

Aqui, usamos a interface List para declarar uma lista encadeada animals1A lista encadeada pode acessar métodos da interface List.

Vamos dar outro exemplo.

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

Aqui, animal2pode acessar métodos da interface Queue.

Mas, animal3Só podem acessar métodos das interfaces Deque e Queue. Isso porque Deque é uma subinterface de Queue.

Métodos da LinkedList

A LinkedList oferece várias métodos, que nos permitem executar diferentes operações na lista encadeada.

Adicionar elemento ao LinkedList

1. Adicionar elemento: }}Usar método add()

Para adicionar um elemento (nó) ao final da lista encadeada, usamos o método add(). Por exemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento ao LinkedList
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

LinkedList: [Dog, Cat, Horse]

2. Adicionar elemento: usar o número de índice

Também podemos usar o índice para adicionar elementos à lista encadeada. Por exemplo,

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

Resultados de saída

LinkedList: [Dog, Cat, Horse]

3. Adicionar elemento: adicionar uma lista encadeada para outra

Para adicionar todos os elementos de uma lista encadeada para outra, usamos o método addAll(). Por exemplo,

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");
　　　　　　　　//Adicionar todos os elementos de mammals para animals
　　　　　　　　animals.addAll(mammals);
　　　　　　　　System.out.println("Animais: ")　+　animals);
　　　　}
}

Resultados de saída

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

4. Adicionar elemento: usar o método listIterator()

Também podemos usar o método listsIterator() para adicionar elementos à lista encadeada. Para usá-lo, devemos importar o pacote java.util.ListIterator. Por exemplo,

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

Resultados de saída

LinkedList: [Dog, Cat]

Acessar elemento LinkedList

1. Acessar elemento: usar o método get()

Para acessar elementos da lista encadeada, podemos usar o método get(). Por exemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Obter elemento da lista encadeada
　　　　　　　　String str = animals.get(1);
　　　　　　　　System.out.print("índice1o elemento: "　+　str);
　　　　}
}

Resultados de saída

LinkedList: [Dog, Horse, Cat]
índice1o elemento: Horse

2. Acessar elemento: usar o método iterator()

Para percorrer os elementos da lista encadeada, podemos usar o método iterator(). Devemos importar o pacote java.util.Iterator para usar este método. Por exemplo,

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　//Criar objeto Iterator
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de saída

LinkedList: Dog, Cat, Horse,

Aqui,

• hasNext() - Se houver um elemento seguinte, retorna true

• next() - Retorna o próximo elemento

3.Acessar elemento: usar método listIterator()

Também podemos usar o método listIterator() para iterar pelos elementos da lista encadeada. Para usar este método, devemos importar o pacote java.util.ListIterator.

O método listsIterator() é mais adequado para usar em listas. Isso porque o objeto listIterator() também pode iterar para trás. Por exemplo,

import java.util.LinkedList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　//Criar objeto ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(listIterate.hasNext()) {
　　　　　　　　　　　　System.out.print(listIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//　Navegação para trás
　　　　　　　　System.out.print("\nLinkedList reversa: ");
　　　　　　　　while(listIterate.hasPrevious()) {
　　　　　　　　　　　　System.out.print(listIterate.previous());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de saída

LinkedList: Dog, Horse, Cat,
LinkedList reversa: Cat, Horse, Dog,

Aqui,

• hasNext() - Se houver um elemento seguinte, retorna true

• next() - Retorna o próximo elemento

• hasPrevious() - Se houver um elemento anterior, retorna true

• previous() - Retorna o elemento anterior

Procurar elemento LinkedList

1.Procurar elemento: usar método contains()

Para verificar se a lista encadeada contém um elemento específico, usamos o método contains(). Por exemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Verificar se Dog está na lista encadeada
　　　　　　　　if(animals.contains("Dog")) {
　　　　　　　　　　　　System.out.println("Dog está na LinkedList.");
　　　　　　　　}
　　　　}
}

Resultados de saída

LinkedList: [Dog, Horse, Cat]
Dog está na LinkedList.

2.Procurar elemento: usar método indexOf()

• indexOf() - Retorna o índice da primeira ocorrência do elemento

• lastIndexOf() - Retorna o índice da última ocorrência do elemento

por exemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//　Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cão");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Primeira ocorrência Dog
　　　　　　　　int index1　= " + animals.indexOf("Dog");
　　　　　　　　System.out.println("Primeira ocorrência Dog: " + "");　+　índice1);
　　　　　　　　//Última ocorrência Dog
　　　　　　　　int index2　= animals.lastIndexOf("Dog");
　　　　　　　　System.out.println("Última ocorrência do índice Dog: ")　+　índice2);
　　　　}
}

Resultados de saída

LinkedList: [Cachorro, Cavalo, Gato, Cachorro]
Primeira ocorrência do índice Dog: 0
Última ocorrência do índice Dog:　3

Atenção:Se não encontrar o elemento especificado, indexOf() e lastIndexOf() retornam-1.

Alterar elemento LinkedList

1.Alterar elemento: usar o método set()

Para alterar elementos na lista encadeada, podemos usar o método set(). Por exemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cão");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Alterar índice de valor3do elemento
　　　　　　　　animals.set(3, "Zebra");
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

LinkedList: [Cachorro, Cavalo, Gato, Cachorro]
Nova LinkedList: [Cachorro, Cavalo, Gato, Zebra]

2.Alterar elemento: usar o método listIterator()

Também podemos usar o método listIterator() para alterar elementos na lista encadeada. Por exemplo,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//　Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Criar objeto ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//Alterar o elemento retornado por next()
　　　　　　　　listIterate.set("Vaca");
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

LinkedList: [Dog, Cat, Horse]
Nova LinkedList: [Vaca, Gato, Cavalo]

Remover elemento LinkedList

1.Remover elemento: usar o método remove()

Para remover elementos da lista encadeada, podemos usar o método remove(). Por exemplo,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Zebra");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Remover índice de valor1do elemento
　　　　　　　　String str = animals.remove(1);
　　　　　　　　System.out.println("Remover elemento: ")　+　str);
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

LinkedList: [Cachorro, Cavalo, Gato, Zebra]
Remover elemento: Cavalo
Nova LinkedList: [Cachorro, Gato, Zebra]

2.Remover elemento: usar o método listIterator()

Também podemos usar o método listsIterator() para remover elementos da lista encadeada. Por exemplo,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Criar objeto ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//Remover o elemento retornado por next()
　　　　　　　　listIterate.remove();
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

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

3.Remover elemento: usando o método clear()

Para remover todos os elementos da lista encadeada, usamos o método clear(). Por exemplo:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Remover todos os elementos
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

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

Atenção:Também podemos usar o método removeAll() para remover todos os elementos. No entanto, o método clear() é mais eficiente que o método removeAll().

4.Remover elemento: usando o método removeIf()

Se o elemento atender a uma condição específica, também podemos removê-lo da lista. Para isso, usamos o método removeIf(). Por exemplo:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<Integer> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add(2);
　　　　　　　　animals.add(3);
　　　　　　　　animals.add(4);
　　　　　　　　animals.add(5);
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//　Remover todos os elementos menores que4do elemento
　　　　　　　　animals.removeIf((Integer i)->i <　4);
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　　　　/**　Aqui usamos a expressão lambda
　　　　　　　*　　Agora, lembre-se
　　　　　　　*　　O parâmetro da função removeIf() é uma condição
　　　　　　　*/
　　　　}
}

Resultados de saída

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

Atenção: (Integer i)->i<4 É uma expressão lambda. Para entender as expressões lambda, acesseExpressões Lambda em Java

LinkedList como Deque e Queue

Como a classe LinkedList também implementa as interfaces Queue e Deque, ela também pode implementar esses métodos. Aqui estão alguns métodos comuns:

Métodos addFirst() e addLast()

• addFirst() - Adicionar o elemento especificado no início da lista encadeada

• addLast() - Adicionar o elemento especificado no final da lista encadeada

por exemplo,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento no início da LinkedList
　　　　　　　　animals.addFirst("Cow");
　　　　　　　　animals.addFirst("Dog");
　　　　　　　　animals.addFirst("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Adicionar elemento no final da LinkedList
　　　　　　　　animals.addLast("Zebra");
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

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

métodos getFirst() e getLast()

• getFirst() - retornar o primeiro elemento

• getLast() - retornar o último elemento

por exemplo,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//obter o primeiro elemento da lista encadeada
　　　　　　　　String str1　= animals.getFirst();
　　　　　　　　System.out.println("primeiro elemento: ")　+　str1);
　　　　　　　　//obter o último elemento da lista encadeada
　　　　　　　　String str2　= animals.getLast();
　　　　　　　　System.out.println("último elemento: ")　+　str2);
　　　　}
}

Resultados de saída

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

métodos removeFirst() e removeLast()

• removeFirst() - remover o primeiro elemento

• removeLast() - remover o último elemento

por exemplo,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//remover o primeiro elemento da LinkedList
　　　　　　　　String str1　= animals.removeFirst();
　　　　　　　　System.out.println("elemento removido: ")　+　str1);
　　　　　　　　//remover o último elemento da LinkedList
　　　　　　　　String str2　= animals.removeLast();
　　　　　　　　System.out.println("elemento removido: ")　+　str2);
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

LinkedList: [Dog, Horse, Cat]
elemento removido: Dog
elemento removido: Cat
nova LinkedList: [Horse]

método peek()

O método peek() retorna o primeiro elemento da lista encadeada (cabeça). Por exemplo,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//acessar o primeiro elemento da LinkedList
　　　　　　　　String str = animals.peek();
　　　　　　　　System.out.println("acesso ao elemento: ")　+　str);
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

LinkedList: [Dog, Horse, Cat]
acesso ao elemento: Dog
Nova LinkedList: [Cão, Cavalo, Gato]

método poll()

O método poll() retorna e remove o primeiro elemento da lista encadeada. Por exemplo,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　animals.add("Gato");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//retorna e remove o primeiro elemento
　　　　　　　　String str = animals.poll();
　　　　　　　　System.out.println("elemento removido: ")　+　str);
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

LinkedList: [Dog, Horse, Cat]
elemento removido: Dog
nova LinkedList: [Horse, Cat]

método offer()

O método offer() adiciona o elemento especificado no final da lista encadeada. Por exemplo,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Adicionar elemento na lista
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Adicionar elemento no final da LinkedList
　　　　　　　　animals.offer("Gato");
　　　　　　　　System.out.println("Nova LinkedList: " );　+　animals);
　　　　}
}

Resultados de saída

LinkedList: [Cão, Cavalo]
Nova LinkedList: [Cão, Cavalo, Gato]

Percorrer a iteração LinkedList

1.Uso de loop forEach para percorrer

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar uma lista encadeada
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Vaca");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cão");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Uso de loop forEach
　　　　　　　　System.out.println("Acessar elementos da lista:");
　　　　　　　　for(String animal: animals) {
　　　　　　　　　　　　System.out.print(animal);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de saída

LinkedList: [Vaca, Gato, Cão,]
Acessar elementos da lista:
Vaca, Gato, Cão,

2.Uso de loop for

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar uma lista encadeada
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Vaca");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cão");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Uso de loop for
　　　　　　　　System.out.println("Acessar elementos da lista:");
　　　　　　　　for(int i=0; i < animals.size(); i++) {
　　　　　　　　　　　　System.out.print(animals.get(i));
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de saída

LinkedList: [Vaca, Gato, Cão,]
Acessar elementos da lista:
Vaca, Gato, Cão,

Nos dois exemplos, usamos um loop para acessar cada elemento da lista.

3.Uso do método iterator()

Podemos usar o método iterator() para acessar os elementos da lista. Para usar este método, devemos importar o pacote java.util.Iterator.

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar uma lista encadeada
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Vaca");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cão");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Uso do método iterator()
　　　　　　　　System.out.println("LinkedList usando o método iterator():");
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de saída

LinkedList: [Vaca, Gato, Cão,]
LinkedList usa o método iterator():
Vaca, Gato, Cão,

LinkedList e ArrayList

LinkedList e ArrayList implementam a interface List do framework Collections, mas existem algumas diferenças entre elas.