linked list java linked list implementation java examples
Questo tutorial spiega cos'è una struttura dati di un elenco collegato in Java e come creare, inizializzare, implementare, attraversare, invertire e ordinare un elenco collegato Java:
In Java, una LinkedList è una struttura di dati che memorizza gli elementi in una posizione non contigua. È una struttura dati lineare.
Ogni elemento di dati è chiamato 'Nodo' e ogni nodo ha una parte di dati e una parte di indirizzo. La parte dell'indirizzo memorizza il collegamento al nodo successivo nella LinkedList.
=> Visita qui per vedere la serie di formazione Java per tutti.
Cosa imparerai:
- LinkedList in Java
- Classe LinkedList Java
- Come creare un elenco collegato in Java
- Implementazione di elenchi collegati in Java
- Attraversa / Stampa elenco collegato in Java
- Metodi LinkedList
- Elenco collegato inverso in Java
- Ordina un elenco collegato in Java
- Rimuovi duplicati
- Elenco collegato circolare in Java
- LinkedList Java 8
- Domande frequenti
- Conclusione
LinkedList in Java
Di seguito è riportato il layout generale di LinkedList:
Come mostrato nella rappresentazione di LinkedList sopra, ogni elemento in LinkedList è il 'Nodo'. Ogni nodo ha due parti, la prima parte memorizza i dati e la seconda parte ha un riferimento o puntatore o indirizzo del nodo successivo nella LinkedList.
qa vs qc nei test del software
Questa disposizione è necessaria poiché i dati in LinkedList sono archiviati in posizioni non contigue, a differenza di Arrays.
L '“Head” della LinkedList è un puntatore che contiene l'indirizzo del primo elemento della LinkedList. L'ultimo nodo della LinkedList è la coda. Come mostrato nella figura sopra, la parte dell'indirizzo dell'ultimo nodo in LinkedList è impostata su 'Null' che indica la fine di LinkedList.
Il diagramma sopra rappresenta un ' Elenco collegato singolarmente 'Che memorizza l'indirizzo solo del nodo successivo nella LinkedList.
Esiste un'altra versione nota come ' Elenco doppiamente collegato 'In cui ogni nodo ha tre parti:
- Indirizzo o riferimento o puntatore all'elemento precedente in LinkedList.
- Parte dati
- Indirizzo o riferimento o puntatore all'elemento successivo in LinkedList.
L'indirizzo precedente del primo elemento in LinkedList verrà impostato su Null mentre il puntatore successivo dell'ultimo elemento in LinkedList è impostato su Null.
Rappresentazione della lista doppiamente collegata:
Come mostrato nella rappresentazione sopra, ogni nodo nell'elenco a doppia connessione ha puntatori al suo nodo precedente e successivo (quindi rappresentato senza frecce). Il puntatore precedente del primo nodo punta a null mentre il puntatore successivo dell'ultimo nodo punta a null.
In questo tutorial su LinkedList, ci occuperemo principalmente dell'elenco collegato singolarmente. Discuteremo la lista doppiamente collegata nel nostro prossimo tutorial.
Classe LinkedList Java
In Java, l'elenco collegato è implementato dal ' Lista collegata ' classe. Questa classe appartiene al ' java.util 'Pacchetto. La classe LinkedList implementa le interfacce List e Deque ed eredita la classe AbstractList.
Di seguito è riportata la gerarchia delle classi della classe LinkedList.
Il diagramma sopra mostra la gerarchia della classe LinkedList. Come mostrato, la classe LinkedList implementa le interfacce List e Deque.
Come già accennato, la classe LinkedList fa parte del ' java.util 'Pacchetto. Quindi dovresti essere in grado di utilizzare la classe LinkedList nel tuo programma includendo una delle seguenti istruzioni nel tuo programma.
import java.util.*;
O
import java.util.LinkedList;
Quindi, in base alla gerarchia di cui sopra, una definizione tipica della classe LinkedList è la seguente:
public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, Serializable
Di seguito sono elencate alcune delle caratteristiche della classe LinkedList che dovresti ricordare:
- Questa classe non è sincronizzata.
- Consente valori duplicati.
- Mantiene l'ordine di inserzione.
- Poiché gli elementi non devono essere spostati durante lo spostamento, la manipolazione degli elementi in esso contenuti è più veloce.
- Questa classe può essere utilizzata per implementare uno stack, una coda e un elenco.
Come creare un elenco collegato in Java
Prima di passare alla creazione di un elenco collegato in Java, esaminiamo prima un nodo dell'elenco collegato in Java.
Come già discusso, un elenco collegato è costituito da nodi. Quindi in Java, possiamo rappresentare una LinkedList come una classe con il suo Node come una classe separata. Quindi questa classe avrà un riferimento al tipo Node.
Questo è mostrato come di seguito:
class LinkedList { Node head; // list head //node - linkedlist class Node { int data; Node next; Node(int d) { data = d; } //constructor to create a new node } }
Per creare un oggetto di tipo LinkedList, esistono due costruttori principali come segue:
# 1) LinkedList ()
La sintassi generale per questo costruttore è:
LinkedList linkedList = new LinkedList();
L'istruzione precedente crea un LinkedList vuoto.
Per esempio,
LinkedList l_list = new LinkedList();
Questo creerà un elenco collegato vuoto denominato l_list.
# 2) LinkedList (Collezione c)
La sintassi generale è:
LinkedList linkedList = new LinkedList (Collection c);
L'istruzione precedente crea una LinkedList con elementi della raccolta c come elementi iniziali.
Come altre strutture di dati della lista che abbiamo già visto, anche la lista collegata può essere inizializzata usando il metodo add, Arrays.asList () o usando il costruttore con la collezione come argomento.
Implementazione di elenchi collegati in Java
Di seguito è riportato un semplice esempio di una struttura dati LinkedList in Java. In questo esempio di implementazione, utilizzeremo il metodo add e il metodo asList per inizializzare gli oggetti LinkedList.
import java.util.*; public class Main{ public static void main(String() args) { //create a LinkedList object and initialize it with Array elements converted to list LinkedList intList = new LinkedList<>(Arrays.asList(10,20,30,40,50)); //print the LinkedList just created System.out.println('Contents of first LinkedList: ' + intList); //create an empty list LinkedList colorsList = new LinkedList<>(); //add elements to the linkedList using add method. colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Cyan'); colorsList.add('Magenta'); // print the LinkedList System.out.println('
Contents of second LinkedList: ' + colorsList); } }
Produzione:
Contenuto della prima LinkedList: (10, 20, 30, 40, 50)
Contenuto della seconda LinkedList: (Rosso, Verde, Blu, Ciano, Magenta)
Il programma precedente mostra la creazione e l'inizializzazione della LinkedList. Innanzitutto, creiamo un LinkedList di tipo Integer e forniamo un array di Integer convertito in list utilizzando il metodo asList come valori iniziali per LinkedList.
Successivamente, creiamo una LinkedList vuota di tipo String e quindi, utilizzando il metodo add, aggiungiamo valori alla LinkedList.
Infine, visualizziamo entrambi gli oggetti LinkedList come una stringa.
Attraversa / Stampa elenco collegato in Java
Per stampare il contenuto o eseguire qualsiasi operazione sugli elementi della LinkedList, è necessario attraversarne gli elementi. Abbiamo già visto questi metodi nei nostri tutorial precedenti. In questa sezione, discuteremo gli esempi di ciascuno rispetto a LinkedList.
Utilizzo del ciclo for
import java.util.LinkedList; class Main { public static void main(String() args) { // Create a LinkedList and initialize it LinkedList colorList = new LinkedList<>(); colorList.add('Red'); colorList.add('Green'); colorList.add('Blue'); // Using for loop,print the contents of the LinkedList System.out.println('LinkedList elements using for loop:'); for(int i=0; i Produzione:
Elementi LinkedList che utilizzano il ciclo for:
Rosso Verde Blu

Utilizzo di forEach Loop
import java.util.LinkedList; class Main { public static void main(String() args) { // Create a LinkedList and initialize it LinkedList colorList = new LinkedList<>(); colorList.add('Red'); colorList.add('Green'); colorList.add('Blue'); // Using forEach loop,print the contents of the LinkedList System.out.println('LinkedList elements using forEach loop:'); for(String color:colorList) { System.out.print(color + ' '); } } }
Produzione:
Elementi LinkedList che utilizzano il ciclo forEach:
Rosso Verde Blu

Utilizzando Iterator
import java.util.*; public class Main{ public static void main(String args()){ //declare a LinkedList object LinkedList l_list=new LinkedList(); //Add elements to LinkedList l_list.add('Red'); l_list.add('Green'); l_list.add('Blue'); l_list.add('Yellow'); //declare an iterator for the LinkedList Iterator itr=l_list.iterator(); System.out.println('The contents of Linked List:'); //Iterate through the LinkedList using Iterator and print its elements while(itr.hasNext()){ System.out.print(itr.next() + ' '); } } }
Produzione:
Il contenuto dell'elenco collegato:
Rosso Verde Blu Giallo
in che modo Java è diverso da C ++

Metodi LinkedList
La classe LinkedList fornisce un'API che supporta vari metodi per manipolare l'elenco collegato. Abbiamo tabularizzato i metodi nell'API LinkedList di seguito.
Discuteremo le principali operazioni / metodi nella sezione seguente.
Metodo Prototipo Descrizione Chiaro void clear () Elimina tutti gli elementi dalla lista. Inserisci booleano add (E e) Aggiungi un elemento specificato a LinkedList void add (int index, E element) Aggiungi elemento all'indice dato in LinkedList Aggiungi tutto booleano addAll (Collezione c) Aggiunge gli elementi della raccolta c data alla fine di LinkedList. booleano addAll (int index, Collection c) Aggiunge gli elementi della raccolta c data all'indice specificato in LinkedList addFirst void addFirst (E e) Aggiungi l'elemento dato come primo elemento a LinkedList. addLast void addLast (E e) Aggiungi l'elemento specificato alla fine dell'elenco. Clone Oggetto clone () Crea una copia superficiale di LinkedList Contiene Boolean contiene (Object o) Controlla se l'elenco contiene elementi specificati; se sì restituisce vero. descendingIterator Iteratore discendente Iteratore () Restituisce un iteratore con ordine inverso per LinkedList. Elemento E elemento () Restituisce l'elemento all'inizio dell'elenco. Ottenere E get (int indice) Ottiene l'elemento in corrispondenza dell'indice specificato. getFirst E getFirst () Recupera il primo elemento in LinkedList. getLast E getLast () Recupera l'ultimo elemento in LinkedList. indice di Int indexOf (Object o) Trova l'indice della prima occorrenza degli elementi dati nell'elenco e restituisci l'indice. -1 se l'elemento non è stato trovato. lastIndexOf Int lastIndexOf (Object o) Restituisce la posizione dell'ultima occorrenza di un dato elemento nella LinkedList; -1 se un dato elemento non è presente listIterator ListIterator listIterator (int index) Restituisce listIterator dall'indice specificato nella lista collegata. Offrire offerta booleana (E e) Aggiunge l'elemento dato come ultimo elemento (coda) in LinkedList. offerFirst Boolean offerFirst (E e) Aggiunge l'elemento dato come primo elemento in LinkedList. offerLast Boolean offerLast (E e) Aggiungi un dato elemento e alla fine di LinkedList. Sbirciare E sbircia () Restituisce l'inizio dell'elenco senza rimuoverlo. peekFirst E peekFirst () Restituisce il primo elemento nell'elenco. restituisce null se l'elenco è vuoto. peekLast E peekLast () Restituisce l'ultimo elemento o null se l'elenco è vuoto. Non elimina l'elemento. Sondaggio E sondaggio () Restituisce l'intestazione della LinkedList e la rimuove. pollFirst E pollFirst () Restituisce ed elimina il primo elemento della lista; restituisce null se l'elenco è vuoto. pollLast E pollLast () Restituisce ed elimina l'ultimo elemento nell'elenco; restituisce null se l'elenco è vuoto. Pop E pop () Estrae l'elemento dalla rappresentazione dello stack di LinkedList. spingere Spinta nulla (E e) Inserisce o inserisce un elemento nella rappresentazione dello stack di LinkedList. Rimuovere E rimuovi () Rimuove e restituisce l'intestazione di LinkedList. E rimuovi (indice int) Elimina l'elemento in corrispondenza dell'indice specificato da LinkedList. booleano remove (Object o) Elimina la prima occorrenza dell'elemento specificato da LinkedList. removeFirst E removeFirst () Restituisce ed elimina il primo elemento dall'elenco. removeFirstOccurence booleano removeFirstOccurrence (Object o) Elimina la prima occorrenza dell'elemento specificato dall'elenco quando l'elenco viene attraversato dalla testa alla coda. removeLast E removeLast () Restituisce l'ultimo elemento in LinkedList e inoltre lo elimina. removeLastOccurence booleano removeLastOccurrence (Object o) Rimuove l'ultima occorrenza dell'elemento specificato da LinkedList quando viene attraversato dalla testa alla coda Impostato E set (int index, E element) Imposta l'elemento dato all'indice dato. Sostituisce l'elemento corrente con nuovo. Taglia Dimensione int () Restituisce la dimensione o il numero di elementi in LinkedList toArray Object () toArray () Converte LinkedList in una matrice contenente tutti gli elementi dell'elenco nella sequenza corretta T () toArray (T () a) Converte LinkedList in un array con il tipo di runtime uguale all'argomento a.
Il programma Java di seguito mostra i vari metodi che abbiamo elencato sopra.
import java.util.*; public class Main { public static void main(String args()) { //create a linked list LinkedList l_list = new LinkedList(); // Add elements to linkedList using various add methods l_list.add('B'); l_list.add('C'); l_list.addLast('G'); l_list.addFirst('A'); l_list.add(3, 'D'); l_list.add('E'); l_list.add('F'); //print the linkedList System.out.println('Linked list : ' + l_list); //Create and initialize an ArrayList ArrayList aList = new ArrayList<>(); aList.add('H'); aList.add('I'); //add the ArrayList to linkedList using addAll method l_list.addAll(aList); //print the linkedList System.out.println('Linked list after adding ArrayList contents: ' + l_list); // use various remove methods to remove elements from linkedList l_list.remove('B'); l_list.remove(3); l_list.removeFirst(); l_list.removeLast(); //print the altered list System.out.println('Linked list after deletion: ' + l_list); // use contains method to check for an element in the linkedList boolean ret_value = l_list.contains('G'); //print the results of contains method if(ret_value) System.out.println('List contains the element 'G' '); else System.out.println('List doesn't contain the element 'G''); // use size methods to return Number of elements in the linked list int size = l_list.size(); System.out.println('Size of linked list = ' + size); // Get and set elements from linked list Object element = l_list.get(3); System.out.println('Element returned by get() : ' + element); l_list.set(3, 'J'); System.out.println('Linked list after change : ' + l_list); //convert linkedList to Array using toArray methods String () list_array = l_list.toArray(new String(l_list.size())); System.out.println('Array obtained from linked List:' + Arrays.toString(list_array)); } }
Produzione:
Elenco collegato: (A, B, C, D, G, E, F)
Elenco collegato dopo aver aggiunto i contenuti di ArrayList: (A, B, C, D, G, E, F, H, I)
Elenco collegato dopo l'eliminazione: (C, D, E, F, H)
L'elenco non contiene l'elemento 'G'
Dimensione della lista collegata = 5
Elemento restituito da get (): F
Elenco collegato dopo la modifica: (C, D, E, J, H)
Array ottenuto dalla lista collegata: (C, D, E, J, H)

Il programma precedente mostra vari metodi della classe LinkedList. Innanzitutto, dichiariamo un LinkedList di tipo String. Quindi utilizziamo varie versioni del metodo add come add, andFirst, addLast, addAll, ecc. Per popolare la LinkedList con i valori.
Qui possiamo aggiungere l'elemento direttamente alla fine dell'elenco o aggiungere l'elemento in una posizione specificata nell'elenco.
Usiamo anche il metodo addFirst per aggiungere un elemento all'inizio della lista e addLast per aggiungere un elemento alla fine della lista. Quindi eseguiamo operazioni di rimozione sulla LinkedList come remove, removeFirst, removeLast, ecc.
Per il metodo remove, possiamo specificare l'elemento da rimuovere oppure possiamo specificare l'indice o la posizione nella LinkedList in cui l'elemento deve essere rimosso. I metodi removeFirst e removeLast rimuovono rispettivamente il primo e l'ultimo elemento nell'elenco.
Quindi cerchiamo nell'elenco un particolare elemento utilizzando il metodo contiene. Successivamente, utilizziamo il metodo size () per recuperare la dimensione o la lunghezza di LinkedList. Quindi utilizziamo i metodi get / set per recuperare il valore in un particolare indice nell'elenco e quindi sostituire un valore in una posizione specificata nell'elenco.
Infine, convertiamo il LinkedList in un Array utilizzando il metodo toArray.
Elenco collegato inverso in Java
Per invertire un elenco collegato in Java, utilizziamo il metodo 'descendingIterator ()' che restituisce un iteratore inverso per l'elenco. Possiamo quindi utilizzare questo iteratore per attraversare l'elenco e visualizzare gli elementi.
Il programma seguente inverte l'elenco collegato utilizzando il metodo descendingIterator ().
import java.util.*; public class Main{ public static void main(String args()){ //create a LinkedList object LinkedList l_list=new LinkedList(); l_list.add('Pune'); l_list.add('Mumbai'); l_list.add('Nagpur'); System.out.println('Linked List : ' + l_list); System.out.println('Linked List in reverse order:'); //use descendingIterator method to get a reverse iterator Iterator iter=l_list.descendingIterator(); //traverse the list using iterator and print the elements. while(iter.hasNext()) { System.out.print(iter.next() + ' '); } } }
Produzione:
Elenco collegato: (Pune, Mumbai, Nagpur)
Elenco collegato in ordine inverso:
Nagpur Mumbai Pune

Nel programma sopra, dichiariamo un elenco collegato e quindi lo stampiamo. Quindi otteniamo un iteratore inverso e quindi scorriamo l'elenco utilizzandolo e visualizziamo ogni elemento. L'output mostra il contenuto dell'elenco collegato, prima nell'ordine in cui vengono aggiunti gli elementi e poi l'output mostra i contenuti in ordine inverso.
Ordina un elenco collegato in Java
Gli oggetti della classe LinkedList possono essere ordinati utilizzando il metodo Collections.sort (). Questo metodo fornisce due versioni con o senza l'utilizzo di un comparatore. Quando il metodo Collections.sort () viene chiamato senza un comparatore, la raccolta viene ordinata in ordine naturale.
Quando il comparatore viene utilizzato con questo metodo, possiamo definire i nostri criteri di ordinamento sovrascrivendo il metodo compareTo.
Il seguente programma Java ordina una LinkedList utilizzando Collections.sort (). Qui ordiniamo gli array utilizzando l'ordinamento naturale e un comparatore.
import java.util.*; public class Main{ public static void main(String args()) { // create and initialize the LinkedList object LinkedList l_list = new LinkedList<>(); l_list.add('Jan'); l_list.add('Feb'); l_list.add('Mar'); l_list.add('Apr'); l_list.add('May'); l_list.add('Jun'); //print original unsorted linkedlist System.out.println('Original LinkedList (unsorted): ' + l_list); // sort LinkedList with Collecitons.sort() method in natural order Collections.sort(l_list); System.out.println('
LinkedList (sorted in natural order): ' + l_list); // sort LinkedList using Collection.sort() and Comparator in Java Collections.sort(l_list, new Comparator() { @Override public int compare(String s1, String s2) { return s1.length() - s2.length(); } } ); System.out.println('LinkedList (sorted using Comparator): ' + l_list); } }
Produzione:
qual è il miglior pulitore gratuito per PC
Elenco collegato originale (non ordinato): (gennaio, febbraio, marzo, aprile, maggio, giugno)
LinkedList (ordinati in ordine naturale): (Apr, Feb, Jan, Jun, Mar, May)
Elenco collegato (ordinato utilizzando il comparatore): (aprile, febbraio, gennaio, giugno, marzo, maggio)

Rimuovi duplicati
Per rimuovere i duplicati, è necessario attraversare ogni nodo e confrontarlo con il nodo successivo. Se entrambi i nodi sono uguali, saltiamo un nodo e passiamo a quello successivo.
In questo modo, dopo aver attraversato ogni nodo e aver eliminato i nodi duplicati, otterremo l'elenco risultante che è senza elementi duplicati.
Di seguito è riportato un programma Java per rimuovere i duplicati.
class LinkedList_Duplicate { //A class to represent node in linkedlist class Node{ int data; Node next; public Node(int data) { this.data = data; this.next = null; } } //Initially the head and tail of the linked list set to null public Node head = null; public Node tail = null; //add a new node to the linkedlist public void addNode(int data) { //Create new node Node newNode = new Node(data); //If list is empty set head and tail to new node if(head == null) { head = newNode; tail = newNode; } else { // add newNode after the tail tail.next = newNode; //newNode is now the tail or last element tail = newNode; } } //scans the linkedlist and removes duplicate nodes public void removeDuplicateNodes() { //Head is the current node Node current = head, index = null, temp = null; //head = null means list is empty if(head == null) { return; } //traverse through the list else { while(current != null){ //temp node points to previous node to index. temp = current; //Index will point to node next to current index = current.next; while(index != null) { //Check if current node's data is equal to index node's data if(current.data == index.data) { //since node is duplicate skip index and point to next node temp.next = index.next; } else { //Temp will point to previous node of index. temp = index; } index = index.next; } current = current.next; } } } //print the linked list public void print() { //Node current will point to head Node current = head; if(head == null) { System.out.println('List is empty'); return; } while(current != null) { //Print each node by incrementing pointer System.out.print(current.data + ' '); current = current.next; } System.out.println(); } }class Main{ public static void main(String() args) { LinkedList_Duplicate l_List = new LinkedList_Duplicate(); //Add data to the list l_List.addNode(1); l_List.addNode(1); l_List.addNode(2); l_List.addNode(3); l_List.addNode(5); l_List.addNode(2); l_List.addNode(1); l_List.addNode(1); //print the original list System.out.println('Original Linkedlist: '); l_List.print(); //Removes duplicate nodes l_List.removeDuplicateNodes(); //print the altered list without duplicates System.out.println('LinkedList after removing duplicates: '); l_List.print(); } }
Produzione:
Linkedlist originale:
1 1 2 3 5 2 1 1
LinkedList dopo aver rimosso i duplicati:
1 2 3 5

Nel programma sopra, abbiamo una classe di elenchi collegati creata per rimuovere i duplicati. Abbiamo anche una classe per definire ogni nodo. In altre parole, i nodi nell'elenco sono gli oggetti di questo nodo di classe. Abbiamo un metodo per aggiungere il nodo a un elenco collegato.
Quindi, nel metodo removeDuplicate, attraversiamo ogni nodo nell'elenco collegato a partire dall'head e confrontiamo ogni nodo successivo per il duplicato. Se viene trovato un duplicato, saltiamo quel nodo e procediamo al nodo successivo.
In questo modo l'ist viene creato saltando i nodi duplicati e l'elenco modificato viene stampato utilizzando il metodo print ().
Elenco collegato circolare in Java
Un elenco collegato circolare è un elenco che ha la coda o l'ultimo nodo collegato alla testa o al primo nodo.
Il diagramma seguente mostra l'elenco collegato circolare in Java.

Come mostrato nel diagramma sopra, la parte dell'indirizzo dell'ultimo nodo o coda dell'elenco collegato non è impostata su null. Invece, punta indietro al primo nodo o capo della lista formando così una lista collegata circolare.
Il programma seguente implementa una lista collegata circolare in cui dobbiamo manipolare i singoli nodi della lista collegata.
class CircularLinkedList { //Node definition for circular linked list public class Node{ int data; Node next; public Node(int data) { this.data = data; } } //Initially head and tail pointers point to null public Node head = null; public Node tail = null; //add new node to the circular linked list public void add(int data){ //Create new node Node newNode = new Node(data); //check if list is empty if(head == null) { //head and tail point to same node if list is empty head = newNode; tail = newNode; newNode.next = head; } else { //tail points to new node if list is not empty tail.next = newNode; //New node becomes new tail. tail = newNode; //tail points back to head tail.next = head; } } //Display the nodes in circular linked list public void displayList() { Node current = head; if(head == null) { System.out.println('The List is empty'); } else { System.out.println('Circular linked list nodes: '); do{ //Print each node of the linked list System.out.print(current.data + ' '); current = current.next; }while(current != head); System.out.println(); } } } class Main{ public static void main(String() args) { //create a CircularLinkedList object CircularLinkedList c_list = new CircularLinkedList(); //Add data to the list c_list.add(10); c_list.add(20); c_list.add(30); c_list.add(40); //Display the nodes in circular linked list c_list.displayList(); } }
Produzione:
Nodi di elenchi collegati circolari:
10 20 30 40

LinkedList Java 8
Sebbene non ci siano altre funzionalità aggiunte specificamente alla classe LinkedList in Java 8, ha comunque introdotto flussi per manipolare i dati.
Il programma seguente mostra l'uso del flusso Java 8 per visualizzare LinkedList.
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String() args) { //create a LinkedList and initialize it to values List colorsList = new LinkedList<>(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Cyan'); colorsList.add('Magenta'); //convert List to stream & print it System.out.println('The contents of LinkedList:'); colorsList.stream().forEach(System.out::println); } }
Produzione:
I contenuti di LinkedList:
Netto
verde
Blu
Ciano
Magenta

Domande frequenti
D # 1) Quando viene utilizzato l'elenco collegato in Java?
Risposta: Poiché è più veloce delle raccolte come ArrayList nelle operazioni di modifica, dovrebbe essere utilizzato nelle applicazioni che richiedono frequenti operazioni di aggiunta / eliminazione. Per le applicazioni che hanno principalmente dati di sola lettura, è possibile utilizzare ArrayList o raccolte simili.
Q # 2) Cos'è ListNode?
Risposta: Un ListNode è una classe di base associata a un elenco collegato in Java e rappresenta le informazioni associate a un singolo elemento o un nodo. Ogni ListNode è costituito da dati e un puntatore o riferimento all'elemento successivo.
Q # 3) L'elenco collegato consente valori nulli?
Risposta: Sì, l'elenco collegato consente qualsiasi numero di valori nulli.
Q # 4) Quali sono i vantaggi di un elenco collegato?
Risposta: alcuni dei vantaggi sono:
- Le operazioni di manipolazione come l'aggiunta e la cancellazione sono più veloci.
- Non è necessario pre-allocare la memoria per un elenco collegato e quindi si ottiene un utilizzo efficiente della memoria.
- Fornisce tempi di accesso più rapidi e senza sovraccarico aggiuntivo per la memoria e può essere espanso in tempo costante.
- È una struttura dati dinamica
- Cresce e si restringe in fase di esecuzione a seconda dei valori aggiunti o eliminati.
Q # 5) Qual è l'applicazione dell'elenco collegato?
Risposta: viene utilizzato principalmente nelle seguenti applicazioni:
- Per implementare la funzionalità di 'annullamento' in software come MS-Word, Photoshop, ecc.
- Per implementare strutture dati come stack e queue.
- Possiamo anche implementare grafici utilizzando un elenco collegato.
- Per l'hashing del bucket, ogni bucket può essere implementato come elenco collegato.
Q # 6) Quali sono i limiti di un elenco collegato?
Risposta: alcune delle limitazioni sono:
- Con un puntatore aggiuntivo per mantenere il riferimento dell'elemento successivo in ogni nodo, la memoria utilizzata è molto di più degli array.
- Questa è una struttura dati ad accesso strettamente sequenziale, quindi i nodi della lista collegata devono essere sempre letti dall'inizio.
- È difficile spostarlo all'indietro, specialmente negli elenchi collegati singolarmente.
- Poiché i nodi sono archiviati in posizioni non contigue, il tempo necessario per l'accesso può essere elevato.
Conclusione
In questo tutorial abbiamo imparato la struttura dei dati di base dell'elenco collegato. Quindi siamo passati alla classe java.util.LinkedList fornita in Java. Abbiamo discusso questa classe in dettaglio, inclusi i suoi costruttori, metodi, ecc.
Abbiamo anche discusso alcune operazioni speciali relative agli elenchi collegati come l'ordinamento, l'inversione di un elenco, la rimozione di duplicati, l'elenco collegato circolare, ecc.
Nel nostro prossimo tutorial, discuteremo delle caratteristiche specifiche della lista doppiamente collegata.
=> Dai un'occhiata alla guida completa alla formazione su Java qui.
Lettura consigliata
- Elenco doppiamente collegato in Java - Esempi di implementazione e codice
- Elenco Java - Come creare, inizializzare e utilizzare l'elenco in Java
- Metodi elenco Java - Ordina elenco, Contiene, Aggiungi elenco, Rimuovi elenco
- Algoritmo di ricerca binaria in Java - implementazione ed esempi
- Ordinamento di inserimento in Java - Algoritmo ed esempi di ordinamento di inserimento
- Tutorial sull'interfaccia Java e sulla classe astratta con esempi
- Struttura Dati Elenco Collegato In C ++ Con Illustrazione
- Elenco nascosto per array e altre raccolte in Java