LinkedList Java

In questo tutorial, esploreremo in dettaglio la classe LinkedList con molti esempi.

La classe LinkedList della Java Collection Framework fornisce le funzionalità della struttura dati lista.

Interfaccia implementata da LinkedList

• Interfaccia Java List

• Interfaccia Queue in Java

• Interfaccia Java Deque

Implementazione di LinkedList in Java

La classe LinkedList di Java fornisce un'implementazione di lista a doppio collegamento.

Ogni elemento nella lista è chiamatoNode. Contiene 3 campi:

• Prev - Memorizza l'indirizzo dell'elemento precedente nella lista. Il primo elemento è null.

• Next - Memorizza l'indirizzo del prossimo elemento nella lista. L'ultimo elemento è null.

• Data - Memorizza i dati effettivi.

Gli elementi nella lista non sono memorizzati in ordine. Al contrario, sono distribuiti e collegati tramite link (Prev e Next).

In questo caso, la lista di link contiene 3 elementi.

• Dog - Il primo elemento imposta null come indirizzo precedente e l'indirizzo di Cat come indirizzo successivo

• Cat - Il secondo elemento imposta l'indirizzo di Dog come indirizzo precedente e l'indirizzo di Cow come indirizzo successivo

• Cow - L'ultimo elemento imposta l'indirizzo di Cat come indirizzo precedente e null come elemento successivo

Creare una LinkedList

Ecco come possiamo creare una lista di link in Java:

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

In questo caso, Type rappresenta il tipo della lista linkata. Ad esempio,

//Creare una lista di interi
//Creare una lista di interi
//Creare una lista di stringhe
LinkedList<String> linkedList = new LinkedList<>();

Creare LinkedList utilizzando l'interfaccia

Facciamo un esempio.

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

In questo caso, abbiamo dichiarato una lista animals1 utilizzando l'interfaccia List, che può accedere solo ai metodi dell'interfaccia List.

Facciamo un altro esempio.

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

In questo caso, animal2 può accedere ai metodi dell'interfaccia Queue.

Ma animal3 può accedere solo ai metodi dell'interfaccia Deque e Queue. Questo perché Deque è un sotto-interfaccia di Queue.

Metodi di LinkedList

LinkedList fornisce vari metodi che ci permettono di eseguire diverse operazioni sulla lista.

Aggiungere elementi alla LinkedList

1. Aggiungere elementi:Utilizzare il metodo add()

Per aggiungere un elemento (nodo) alla fine della lista, utilizziamo il metodo add(). Ad esempio,

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

Risultato di output

LinkedList: [Dog, Cat, Horse]

2. Aggiungere elementi: utilizzare il numero di indice

Possiamo anche utilizzare l'indice per aggiungere elementi alla lista. Ad esempio,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Aggiungere elementi utilizzando l'indice
　　　　　　　　animals.add(0, "Dog");
　　　　　　　　animals.add(1, "Cat");
　　　　　　　　animals.add(2, "Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Cat, Horse]

3. Aggiungere elementi: aggiungere una lista a un'altra lista

Per aggiungere tutti gli elementi di una lista a un'altra lista, utilizziamo il metodo addAll(). Ad esempio,

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("Mammals: " + mammals);
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Crocodile");
　　　　　　　　// Add all elements of mammals to animals
　　　　　　　　animals.addAll(mammals);
　　　　　　　　System.out.println("Animals:　" + animals);
　　　　{}
{}

Risultato di output

Mammals:　[Dog,　Cat,　Horse]
Animals:　[Crocodile,　Dog,　Cat,　Horse]

4. Adding elements: using the listIterator() method

We can also use the listsIterator() method to add elements to the linked list. To use it, we must import the java.util.ListIterator package. For example,

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

Risultato di output

LinkedList:　[Dog,　Cat]

Accessing LinkedList elements

1. Accessing elements: using the get() method

To access elements in the linked list, we can use the get() method. For example,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　// Get element from the linked list
　　　　　　　　String str = animals.get(1);
　　　　　　　　System.out.print("Element at index 1:　" + str);
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Horse, Cat]
Element at index 1:　Horse

2. Accessing elements: using the iterator() method

To iterate over the elements of the linked list, we can use the iterator() method. We must import the java.util.Iterator package to use this method. For example,

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　// Create an Iterator object
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("LinkedList:　");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

Risultato di output

LinkedList:　Dog,　Cat,　Horse,

Ecco qui:

• hasNext() - Restituisce true se esiste un elemento successivo

• next() - Restituisce l'elemento successivo

3. Accessing elements: using the listIterator() method

We can also use the listIterator() method to iterate over the elements of a linked list. To use this method, we must import the java.util.ListIterator package.

The listsIterator() method is more suitable for use with linked lists. This is because the objects of listIterator() can also iterate backward. For example

import java.util.LinkedList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Creare l'oggetto ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　System.out.print("LinkedList:　");
　　　　　　　　while(listIterate.hasNext())　{
　　　　　　　　　　　　System.out.print(listIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　　　　　//　Forward iteration
　　　　　　　　System.out.print("\nReverse LinkedList:　");
　　　　　　　　while(listIterate.hasPrevious()) {
　　　　　　　　　　　　System.out.print(listIterate.previous());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

Risultato di output

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

Ecco qui:

• hasNext() - Restituisce true se esiste un elemento successivo

• next() - Restituisce l'elemento successivo

• hasPrevious() - Restituisce true se esiste un elemento precedente

• previous() - Restituisce l'elemento precedente

Ricerca dell'elemento LinkedList

1. Ricerca dell'elemento: utilizzo del metodo contains()

Per verificare se la coda contiene un elemento specifico, utilizziamo il metodo contains(). Ad esempio:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Verifica se Dog è nella coda
　　　　　　　　if(animals.contains("Dog")) {
　　　　　　　　　　　　System.out.println("Dog è nel LinkedList.");
　　　　　　　　{}
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Horse, Cat]
Dog è nel LinkedList.

2. Ricerca dell'elemento: utilizzo del metodo indexOf()

• indexOf() - Restituisce l'indice della prima occorrenza dell'elemento

• lastIndexOf() - Restituisce l'indice dell'ultima occorrenza dell'elemento

Ad esempio,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunge elementi alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Prima occorrenza di Dog
　　　　　　　　int index1 = animals.indexOf("Dog");
　　　　　　　　System.out.println("Indice della prima occorrenza di Dog: " + index1);
　　　　　　　　//Ultima occorrenza di Dog
　　　　　　　　int index2 = animals.lastIndexOf("Dog");
　　　　　　　　System.out.println("Indice dell'ultima occorrenza di Dog: " + index2);
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Horse, Cat, Dog]
Indice della prima occorrenza di Dog: 0
Indice dell'ultima occorrenza di Dog: 3

Attenzione:Se non si trova l'elemento specificato, indexOf() e lastIndexOf() restituiscono -1.

Modifica dell'elemento LinkedList

1. Modifica dell'elemento: utilizzo del metodo set()

Per modificare un elemento nella lista collegata, possiamo utilizzare il metodo set(). Ad esempio:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Modifica l'elemento all'indice 3
　　　　　　　　animals.set(3, "Zebra");
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Horse, Cat, Dog]
Nuovo LinkedList: [Dog, Horse, Cat, Zebra]

2. Modificare gli elementi: utilizzare il metodo listIterator()

Si può anche utilizzare il metodo listIterator() per modificare gli elementi nella lista linkata. Ad esempio,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Aggiunge elementi alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Creare l'oggetto ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//Modificare l'elemento restituito da next()
　　　　　　　　listIterate.set("Cow");
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Cat, Horse]
Nuovo LinkedList: [Cow, Cat, Horse]

Eliminare gli elementi LinkedList

1. Eliminare gli elementi: utilizzare il metodo remove()

Per eliminare un elemento dalla lista linkata, possiamo utilizzare il metodo remove(). Ad esempio,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Zebra");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Eliminare l'elemento con l'indice 1
　　　　　　　　String str = animals.remove(1);
　　　　　　　　System.out.println("Eliminare l'elemento: " + str);
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

LinkedList : [Dog, Horse, Cat, Zebra]
Eliminare l'elemento: Horse
Nuovo LinkedList: [Dog, Cat, Zebra]

2. Eliminare gli elementi: utilizzare il metodo listIterator()

Si può anche utilizzare il metodo listsIterator() per eliminare gli elementi dalla lista linkata. Ad esempio,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Creare l'oggetto ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//Eliminare l'elemento restituito da next()
　　　　　　　　listIterate.remove();
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

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

3. Eliminare gli elementi: utilizzare il metodo clear()

Per eliminare tutti gli elementi dalla lista linkata, utilizziamo il metodo clear(). Ad esempio,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Eliminare tutti gli elementi
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

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

Attenzione:Si può anche utilizzare il metodo removeAll() per eliminare tutti gli elementi. Tuttavia, il metodo clear() è più efficiente del metodo removeAll().

4. Elimina elementi: utilizza il metodo removeIf()

Se un elemento soddisfa una condizione specifica, possiamo anche eliminarlo dalla LinkedList. Per farlo, utilizziamo il metodo removeIf(). Ad esempio:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<Integer> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add(2);
　　　　　　　　animals.add(3);
　　　　　　　　animals.add(4);
　　　　　　　　animals.add(5);
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　// Elimina tutti gli elementi inferiori a 4
　　　　　　　　animals.removeIf((Integer i)->i < 4);
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　　　　/** Qui abbiamo utilizzato l'espressione lambda
　　　　　　　* Ora ricordati
　　　　　　　* Il parametro di removeIf() è una condizione
　　　　　　　*/
　　　　{}
{}

Risultato di output

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

Attenzione: (Integer i)->i<4 è un'espressione lambda. Per saperne di più sulle espressioni lambda, visitaEspressioni Lambda Java

LinkedList come Deque e Queue

Poiché la classe LinkedList ha implementato anche l'interfaccia Queue e Deque, può anche implementare i metodi di queste interfacce. Ecco alcuni metodi comuni:

metodi addFirst() e addLast()

• addFirst() - aggiungi l'elemento specificato all'inizio della lista collegata

• addLast() - aggiungi l'elemento specificato alla fine della lista collegata

Ad esempio,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//Aggiungi un elemento all'inizio della LinkedList
　　　　　　　　animals.addFirst("Cow");
　　　　　　　　animals.addFirst("Dog");
　　　　　　　　animals.addFirst("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Aggiunta di un elemento alla fine della LinkedList
　　　　　　　　animals.addLast("Zebra");
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

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

metodi getFirst() e getLast()

• getFirst() - restituisce l'elemento primo

• getLast() - restituisce l'elemento ultimo

Ad esempio,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunge elementi alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//获取链表中的第一个元素
　　　　　　　　String str1 = animals.getFirst();
　　　　　　　　System.out.println("Primo elemento: " + str1);
　　　　　　　　// Ottiene l'ultimo elemento dalla lista collegata
　　　　　　　　String str2 = animals.getLast();
　　　　　　　　System.out.println("Ultimo elemento: " + str2);
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Horse, Cat]
Primo elemento: Dog
Ultimo elemento: Cat

Metodi removeFirst() e removeLast()

• removeFirst() - Elimina il primo elemento

• removeLast() - Elimina l'ultimo elemento

Ad esempio,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunge elementi alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Elimina il primo elemento dalla LinkedList
　　　　　　　　String str1 = animals.removeFirst();
　　　　　　　　System.out.println("Elemento eliminato: " + str1);
　　　　　　　　//Elimina l'ultimo elemento dalla LinkedList
　　　　　　　　String str2 = animals.removeLast();
　　　　　　　　System.out.println("Elemento eliminato: " + str2);
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Horse, Cat]
Elemento eliminato: Dog
Elemento eliminato: Cat
Nuova LinkedList: [Horse]

Il metodo peek()

Il metodo peek() restituisce il primo elemento della lista collegata (testa). Ad esempio,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Accede al primo elemento della LinkedList
　　　　　　　　String str = animals.peek();
　　　　　　　　System.out.println("Accesso agli elementi: " + str);
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Horse, Cat]
Accesso agli elementi: Dog
Nuova LinkedList: [Dog, Horse, Cat]

Il metodo poll()

Il metodo poll() restituisce ed elimina il primo elemento dalla lista collegata. Ad esempio,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Restituisce ed elimina il primo elemento
　　　　　　　　String str = animals.poll();
　　　　　　　　System.out.println("Elemento eliminato: " + str);
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

LinkedList: [Dog, Horse, Cat]
Elemento eliminato: Dog
Nuova LinkedList: [Horse, Cat]

Il metodo offer()

Il metodo offer() aggiunge l'elemento specificato alla fine della lista collegata. Ad esempio,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Aggiunta di un elemento alla lista
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Aggiunta di un elemento alla fine della LinkedList
　　　　　　　　animals.offer("Cat");
　　　　　　　　System.out.println("Nuova LinkedList: " + animals);
　　　　{}
{}

Risultato di output

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

Esplorazione della LinkedList iterativa

1. Utilizzo del ciclo forEach per esplorare

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Creazione di una lista
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Utilizzo del ciclo forEach
　　　　　　　　System.out.println("Accesso agli elementi della lista:");
　　　　　　　　for(String animal: animals) {
　　　　　　　　　　　　System.out.print(animal);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

Risultato di output

LinkedList: [Mucca, Gatto, Cane,]
Accesso agli elementi della lista:
Mucca, Gatto, Cane,

2. Utilizzo del ciclo for

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Creazione di una lista
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Utilizzo del ciclo for
　　　　　　　　System.out.println("Accesso agli elementi della lista:");
　　　　　　　　for(int i = 0; i < animals.size(); i++) {
　　　　　　　　　　　　System.out.print(animals.get(i));
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

Risultato di output

LinkedList: [Mucca, Gatto, Cane,]
Accesso agli elementi della lista:
Mucca, Gatto, Cane,

In entrambi gli esempi, utilizziamo un ciclo per accedere agli elementi della lista.

3. Utilizzo del metodo iterator()

Possiamo utilizzare il metodo iterator() per accedere agli elementi della lista. Per utilizzare questo metodo, dobbiamo importare il pacchetto java.util.Iterator.

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Creazione di una lista
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//Utilizzo del metodo iterator()
　　　　　　　　System.out.println("LinkedList utilizzando il metodo iterator():");
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

Risultato di output

LinkedList: [Mucca, Gatto, Cane,]
LinkedList utilizza il metodo iterator():
Mucca, Gatto, Cane,

LinkedList e ArrayList

LinkedList e ArrayList implementano l'interfaccia List del framework Collections. Tuttavia, esistono alcune differenze tra loro.