Tilknyttet liste i Java - Implementering af sammenkædet liste og Java-eksempler

linked list java linked list implementation java examples

Prøv Vores Instrument Til At Fjerne Problemer

Vælg Operativsystemet Vælg Et Projektionsprojekt (Valgfrit)

Beskriv Dit Problem

Denne vejledning forklarer, hvad der er en sammenkædet listedatastruktur i Java, og hvordan man opretter, initialiserer, implementerer, gennemgår, vender om og sorterer en Java-sammenkædet liste:

I Java er en LinkedList en datastruktur, der gemmer elementer på en ikke-sammenhængende placering. Det er en lineær datastruktur.

Hvert dataelement kaldes en 'Node', og hver node har en datadel og en adressedel. Adressedelen gemmer linket til den næste knude i LinkedList.

=> Besøg her for at se Java Training Series for alle.

Tilknyttet liste i Java

Hvad du lærer:

LinkedList I Java
Konklusion
- Anbefalet læsning

LinkedList I Java

Nedenfor er det generelle layout af LinkedList:

generelt layout af LinkedList

Som vist i ovenstående repræsentation af LinkedList, er hvert element i LinkedList “Node”. Hver node har to dele, den første del gemmer dataene, og den anden del har en reference eller markør eller adresse til den næste node i LinkedList.

css3 interview spørgsmål og svar pdf

Dette arrangement er nødvendigt, da dataene i LinkedList er gemt på ikke-sammenhængende steder i modsætning til Arrays.

“Hovedet” på LinkedList er en markør, der indeholder adressen på det første element i LinkedList. Den sidste knude i LinkedList er halen. Som vist i figuren ovenfor er adressedel af den sidste node i LinkedList indstillet til 'Null', der angiver slutningen af LinkedList.

Ovenstående diagram repræsenterer en “ Enkeltkædet liste ”Der kun gemmer adressen på den næste knude i LinkedList.

Der er en anden version kendt som “ Dobbelt sammenkædet liste ”Hvis hver node har tre dele:

Adresser eller henvis eller markør til det forrige element i LinkedList.
Datadel
Adresser eller henvis eller markør til det næste element i LinkedList.

Den forrige adresse på det første element i LinkedList vil blive indstillet til Null, mens den næste markør for det sidste element i LinkedList er indstillet til Null.

Repræsentation af dobbeltkoblet liste:

dobbeltkoblet liste

Som vist i ovenstående repræsentation har hver node på den dobbeltkoblede liste pegepunkter til sin forrige og næste node (således repræsenteret uden pile). Den forrige markør i den første node peger på null, mens den næste markør i den sidste node peger på null.

I denne LinkedList-selvstudie beskæftiger vi os hovedsageligt med den enkeltlinkede liste. Vi vil diskutere den dobbeltkoblede liste i vores næste vejledning.

Java LinkedList-klasse

I Java implementeres den linkede liste af “ LinkedList ”Klasse. Denne klasse tilhører ” java.util ' pakke. Klassen LinkedList implementerer grænsefladerne List og Deque og arver klassen AbstractList.

Nedenfor er klassehierarkiet for LinkedList-klassen.

klassehierarki i klassen LinkedList

Ovenstående diagram viser hierarkiet for klassen LinkedList. Som vist implementerer LinkedList-klassen List- og Deque-grænsefladerne.

Som allerede nævnt er klassen LinkedList en del af “ java.util ' pakke. Derfor skal du være i stand til at bruge LinkedList-klassen i dit program ved at medtage en af følgende udsagn i dit program.

import java.util.*;

Eller

import java.util.LinkedList;

Så baseret på ovenstående hierarki er en typisk definition af LinkedList-klassen som følger:

public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, Serializable

Nedenfor er nogle af de kendetegn ved klassen LinkedList, som du skal huske:

Denne klasse er ikke synkroniseret.
Det tillader duplikerede værdier.
Bevarer indsætningsrækkefølgen.
Da det ikke er nødvendigt, at elementer forskydes under bevægelse, er manipulationen af elementerne i det hurtigere.
Denne klasse kan bruges til at implementere en stak, kø og liste.

Sådan oprettes en sammenkædet liste i Java

Før vi går videre til oprettelse af en linkliste i Java, lad os først diskutere en linket listeknude i Java.

Som allerede diskuteret består en sammenkædet liste af noder. Således i Java kan vi repræsentere en LinkedList som en klasse med dens node som en separat klasse. Derfor vil denne klasse have en henvisning til nodetypen.

Dette vises som nedenfor:

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 } }

For at oprette et objekt af typen LinkedList er der to hovedkonstruktører som følger:

# 1) LinkedList ()

Den generelle syntaks for denne konstruktør er:

LinkedList linkedList = new LinkedList();

Ovenstående erklæring opretter en tom LinkedList.

For eksempel,

LinkedList l_list = new LinkedList();

Dette opretter en tom sammenkædet liste med navnet l_list.

# 2) LinkedList (samling c)

Den generelle syntaks er:

LinkedList linkedList = new LinkedList (Collection c);

Ovenstående erklæring opretter en LinkedList med elementer fra samlingen c som dens indledende elementer.

Ligesom andre listedatastrukturer, som vi allerede har set, kan den sammenkædede liste også initialiseres ved hjælp af add-metoden, Arrays.asList () -metoden eller ved at bruge konstruktøren med samlingen som et argument.

Implementering af sammenkædet liste i Java

Nedenfor er et simpelt eksempel på en LinkedList-datastruktur i Java. I dette eksempel på implementering bruger vi add-metoden og asList-metoden til at initialisere de LinkedList-objekter.

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); } }

Produktion:

Indholdet af den første LinkedList: (10, 20, 30, 40, 50)
Indholdet af anden LinkedList: (Rød, grøn, blå, cyan, magenta)

outputlinket implementering af listen

Ovenstående program viser oprettelsen og initialiseringen af LinkedList. Først opretter vi en LinkedList af typen Integer og leverer en matrix af heltal konverteret til liste ved hjælp af asList-metoden som indledende værdier for den LinkedList.

Derefter opretter vi en tom LinkedList af typen String, og derefter tilføjer vi værdier til LinkedList ved hjælp af tilføjelsesmetoden.

Endelig viser vi begge de LinkedList-objekter som en streng.

Travers / Print Linked List i Java

For at udskrive indholdet eller udføre handlinger på elementerne i LinkedList skal du krydse gennem dets elementer. Vi har allerede set disse metoder i vores tidligere tutorials. I dette afsnit vil vi diskutere eksemplerne på hver med hensyn til LinkedList.

Brug for 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 for loop,print the contents of the LinkedList System.out.println('LinkedList elements using for loop:'); for(int i=0; i  Produktion: 
 LinkedList-elementer, der bruger for loop: 
Rød Grøn Blå
  
 Brug 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 + ' '); } } }  Produktion: 
 LinkedList-elementer ved hjælp af forEach loop: 
Rød Grøn Blå
  
 Brug af 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() + ' '); } } }  Produktion: 
 Indholdet af sammenkædet liste: 
Rød Grøn Blå Gul
den bedste mobiltelefon spion app
  
 LinkedList-metoder
 LinkedList-klasse giver API, der understøtter forskellige metoder til at manipulere den Linked-liste. Vi har tabuleret metoderne i LinkedList API nedenfor.
  Vi diskuterer de vigtigste operationer / metoder i det følgende afsnit. 
   Metode Prototype Beskrivelse  
 
  Klar ugyldigt klart () Sletter alle elementerne fra listen.  
 Tilføje boolsk tilføjelse (E e) Føj et specificeret element til LinkedList  
  ugyldig tilføjelse (int-indeks, E-element) Tilføj element ved det givne indeks i LinkedList  
  Tilføj alle boolsk addAll (samling c) Tilføjer elementerne i den givne samling c i slutningen af LinkedList.  
  boolsk addAll (int-indeks, samling c) Tilføjer elementerne i den givne samling c ved det angivne indeks i LinkedList  
  addFirst ugyldig addFirst (E e) Føj det givne element som det første element til LinkedList.  
  addLast ugyldig addLast (E e) Tilføj det givne element i slutningen af listen.  
   Klon Objektklon () Opretter en lav kopi af LinkedList  
  Indeholder Boolsk indeholder (Objekt o) Kontrollerer, om listen indeholder specificerede elementer; hvis ja returnerer sandt.  
  faldendeIterator Iterator faldendeIterator () Returnerer en omvendt ordnet iterator til LinkedList.  
  Element E-element () Returnerer elementet øverst på listen.  
  Få E get (int-indeks) Får elementet til det angivne indeks.  
  getFirst E getFirst () Henter det første element i LinkedList.  
  getLast E getLast () Henter det sidste element i LinkedList.  
  indeks af Int indexOf (Objekt o) Find indekset for den første forekomst af de givne elementer på listen, og returner indekset. -1 hvis element ikke blev fundet.  
  lastIndexOf Int lastIndexOf (Objekt o) Returnerer positionen for den sidste forekomst af det givne element i LinkedList; -1, hvis givent element ikke er til stede  
  listIterator ListIterator listIterator (int index) Returnerer listIterator fra det angivne indeks på den sammenkædede liste.  
  Tilbud boolsk tilbud (E e) Tilføjer det givne element som det sidste element (hale) i LinkedList.  
  tilbudFørst Boolsk tilbudFirst (E e) Tilføjer det givne element som det første element i LinkedList.  
  offerLast Boolsk tilbudLast (E e) Tilføj givet element e i slutningen af LinkedList.  
  Kig E kigger () Returnerer lederen af listen uden at fjerne den.  
  kigFørst E peekFirst () Returnerer det første element på listen. returnerer null, hvis listen er tom.  
  kig sidst E peekLast () Returnerer det sidste element eller null, hvis listen er tom. Det sletter ikke elementet.  
  Afstemning E-afstemning () Returnerer hovedet på LinkedList og fjerner det også.  
  afstemningFørst E pollFirst () Returnerer og sletter det første element på listen; returnerer null, hvis listen er tom.  
  pollLast E pollLast () Returnerer og sletter det sidste element på listen; returnerer null, hvis listen er tom.  
  Pop E pop () Popper elementet fra stakrepræsentationen af LinkedList.  
  Skubbe Annulleret tryk (E e) Skubber eller indsætter et element i stakrepræsentationen på LinkedList.  
  Fjerne E fjern () Fjerner og returnerer hovedet på LinkedList.  
  E fjern (int-indeks) Sletter elementet ved det givne indeks fra LinkedList.  
  boolsk fjernelse (Objekt o) Sletter den første forekomst af det givne element fra LinkedList.  
  Fjern første E removeFirst () Returnerer og sletter det første element fra listen.  
  removeFirstOccurence boolsk removeFirstOccurrence (Objekt o) Sletter den første forekomst af det givne element fra listen, når listen krydses fra hoved til hale.  
  Fjern sidste E removeLast () Returnerer det sidste element i LinkedList og sletter det også.  
  removeLastOccurence boolean removeLastOccurrence (Objekt o) Fjerner den sidste forekomst af det givne element fra LinkedList, når den krydses fra hoved til hale  
  Sæt E-sæt (int-indeks, E-element) Indstiller det givne element ved det givne indeks. Erstatter det aktuelle element med nyt.  
  Størrelse Int-størrelse () Returnerer størrelse eller antal elementer i LinkedList  
  toArray Objekt () toArray () Konverterer LinkedList til et array, der indeholder alle listeelementer i korrekt rækkefølge  
  T () til Array (T () a) Konverterer LinkedList til en matrix med runtime-typen samme som argument a.  
 
 
  Nedenstående Java-program demonstrerer de forskellige metoder, som vi nævnte ovenfor. 
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)); } } Produktion: 
 Sammenkædet liste: (A, B, C, D, G, E, F) 
Sammenkædet liste efter tilføjelse af ArrayList-indhold: (A, B, C, D, G, E, F, H, I) 
Sammenkædet liste efter sletning: (C, D, E, F, H) 
Listen indeholder ikke elementet 'G' 
Størrelse på linket liste = 5 
Element returneret af get (): F 
Sammenkædet liste efter ændring: (C, D, E, J, H) 
Array opnået fra sammenkædet liste: (C, D, E, J, H)
  
 Ovenstående program demonstrerer forskellige metoder i LinkedList-klassen. Først erklærer vi en LinkedList af typen String. Derefter bruger vi forskellige versioner af add-metoden som add, andFirst, addLast, addAll osv. Til at udfylde LinkedList med værdier.
 Her kan vi tilføje elementet direkte i slutningen af listen eller tilføje elementet på en bestemt position på listen.
 Vi bruger også addFirst-metoden til at tilføje et element i begyndelsen af listen og addLast for at tilføje et element i slutningen af listen. Derefter udfører vi fjernoperationer på LinkedList som remove, removeFirst, removeLast osv.
 For at fjerne metoden kan vi enten specificere det element, der skal fjernes, eller vi kan specificere indekset eller placeringen i den LinkedList, hvor elementet skal fjernes. Metoderne removeFirst og removeLast fjern henholdsvis det første og sidste element på listen.
 Derefter søger vi på listen efter et bestemt element ved hjælp af metoden indeholder. Dernæst bruger vi størrelsesmetoden () til at hente størrelsen eller længden af LinkedList. Derefter bruger vi get / set-metoder til at hente værdien ved et bestemt indeks på listen og derefter erstatte en værdi på en bestemt position på listen.
  Endelig konverterer vi LinkedList til en Array ved hjælp af toArray-metoden. 
 Omvendt sammenkædet liste i Java
 For at vende en sammenkædet liste i Java bruger vi metoden “descendingIterator ()”, der returnerer en omvendt iterator til listen. Vi kan derefter bruge denne iterator til at krydse gennem listen og vise elementer.
  Nedenstående program vender den sammenkædede liste ved hjælp af metoden 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() + ' '); } } }  Produktion: 
 Tilknyttet liste: (Pune, Mumbai, Nagpur) 
Sammenkædet liste i omvendt rækkefølge: 
Nagpur Mumbai Pune
  
 I ovenstående program erklærer vi en sammenkædet liste og udskriver den derefter. Derefter får vi en omvendt iterator og går derefter gennem listen ved hjælp af den og viser hvert element. Outputtet viser det sammenkædede listeindhold, først i den rækkefølge, elementerne tilføjes, og derefter viser output indholdet i omvendt rækkefølge.
 Sorter en sammenkædet liste i Java
 LinkedList-klasseobjekter kan sorteres ved hjælp af Collections.sort () -metoden. Denne metode giver to versioner med eller uden brug af en komparator. Når metoden Collections.sort () kaldes uden en komparator, sorteres samlingen i den naturlige rækkefølge.
 Når komparator bruges med denne metode, kan vi definere vores egne sorteringskriterier ved at tilsidesætte sammenligningsmetoden.
  Nedenstående Java-program sorterer en LinkedList ved hjælp af Collections.sort (). Her sorterer vi arrays ved hjælp af naturlig rækkefølge såvel som ved hjælp af en komparator. 
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); } } Produktion: 
 Original LinkedList (usorteret): (Jan, Feb, Mar, Apr, May, Jun) 
LinkedList (sorteret i naturlig rækkefølge): (Apr, Feb, Jan, Jun, Mar, May) 
LinkedList (sorteret ved hjælp af Comparator): (Apr, Feb, Jan, Jun, Mar, May)
  
 Fjern duplikater
 For at fjerne dubletter skal du krydse hver node og sammenligne den med den næste node. Hvis begge noder er ens, springer vi over en node og flytter til den næste.
 Efter at have krydset hver eneste knude og slippe af med duplikatnoder får vi på denne måde den resulterende liste uden duplikatelementer.
  Nedenfor er et Java-program til fjernelse af dubletter. 
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(); } }  Produktion: 
 Oprindelig sammenkædningsliste: 
1 1 2 3 5 2 1 1 
LinkedList efter fjernelse af dubletter: 
1 2 3 5
  
 I ovenstående program har vi oprettet en sammenkædet listeklasse for at fjerne dubletter. Vi har også en klasse til at definere hver node. Med andre ord er noderne på listen genstandene for denne klasseknude. Vi har en metode til at føje noden til en linket liste.
 Derefter krydser vi gennem metoden removeDuplicate gennem hver node i den linkede liste startende fra hovedet og sammenligner hver efterfølgende node for duplikatet. Hvis der findes en duplikat, springer vi den node over og fortsætter til den næste node.
 På denne måde bygges ist ved at springe de dobbelte noder over, og den ændrede liste udskrives ved hjælp af udskrivningsmetoden ().
 Cirkulær sammenkædet liste i Java
 En cirkulær sammenkædet liste er en liste, der har sin hale eller sidste knude forbundet tilbage til hovedet eller den første knude.
  Nedenstående diagram viser den cirkulære sammenkædede liste i Java. 
  
 Som vist i ovenstående diagram er adressedelen af den sidste node eller hale på den linkede liste ikke sat til null. I stedet peger den tilbage på den første node eller leder af listen og danner således en cirkulær sammenkædet liste.
  Nedenstående program implementerer en cirkulær sammenkædet liste, hvor vi skal manipulere individuelle noder på den sammenkædede liste. 
 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(); } }  Produktion: 
 Cirkulært sammenkædede listeknuder: 
10 20 30 40
  
 Java 8 LinkedList
 Selvom der ikke er flere funktioner tilføjet specifikt til LinkedList-klassen i Java 8, introducerede den stadig streams til at manipulere data.
  Nedenstående program viser brugen af Java 8 stream til at vise 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); } } Produktion: 
 Indholdet af LinkedList: 
Net 
Grøn 
Blå 
Cyan 
Magenta
  
 Ofte stillede spørgsmål
  Q # 1) Hvornår bruges den sammenkædede liste i Java? 
  Svar: Da det er hurtigere end samlinger som ArrayList i ændringer, skal det bruges i applikationer, der kræver hyppige tilføjelses- / sletningsoperationer. Til applikationer, der for det meste har skrivebeskyttede data, kan ArrayList eller lignende samlinger bruges.
flet sorter kildekode c ++
  Q # 2)  Hvad er ListNode? 
  Svar: En ListNode er en grundlæggende klasse, der er knyttet til en linket liste i Java og repræsenterer oplysninger, der er knyttet til et enkelt element eller en node. Hver ListNode består af data og en markør eller henvisning til det næste element.
  Q # 3)  Tillader den sammenkædede liste nulværdier? 
  Svar: Ja, den linkede liste tillader et hvilket som helst antal nulværdier.
  Q # 4)  Hvad er fordelene ved en sammenkædet liste? 
  Svar: Nogle af fordelene er: 
  Manipulationsoperationer som tilføjelse, sletning er hurtigere i den.
 Der er ikke behov for at forhåndsallokere hukommelse til en linket liste, og det resulterer således i effektiv hukommelsesudnyttelse.
 Det giver hurtigere adgangstid og uden ekstra omkostninger til hukommelse og kan udvides i konstant tid.
 Det er en dynamisk datastruktur
 Vokser og krymper ved kørselstid afhængigt af værdier tilføjet eller slettet.
 
  Q # 5)  Hvad er anvendelsen af den sammenkædede liste? 
  Svar: Det bruges hovedsageligt i følgende applikationer: 
  At implementere 'fortryd' funktionalitet i software som MS-Word, Photoshop osv.
 At implementere datastrukturer som stak og kø.
 Vi kan også implementere grafer ved hjælp af en linket liste.
 For skovhashning kan hver skovl implementeres som en sammenkædet liste.
 
  Q # 6)  Hvad er begrænsningerne ved en sammenkædet liste? 
  Svar: Nogle af begrænsningerne er: 
  Med en ekstra markør til at indeholde referencen for det næste element i hver node er den anvendte hukommelse meget mere end arrays.
 Dette er en datastruktur, der er strengt adgang til sekventielt, og derfor skal noder på den linkede liste altid læses fra starten.
 Det er vanskeligt at krydse det bagud, især de enkeltstående lister.
 Da noderne er gemt på ikke-sammenhængende placeringer, kan den tid, der kræves for adgang, være høj.
 
 Konklusion
 I denne vejledning har vi lært den grundlæggende linkede datastruktur. Så flyttede vi videre til java.util.LinkedList-klassen, der blev leveret i Java. Vi diskuterede denne klasse i detaljer inklusive dens konstruktører, metoder osv.
 Vi har også diskuteret nogle specielle operationer relateret til sammenkædede lister som sortering, omvendt en liste, fjernelse af dubletter, cirkulær sammenkædningsliste osv.
   I vores næste vejledning vil vi diskutere specifikke funktioner på den dobbeltkoblede liste.  
  => Tjek den komplette Java-træningsvejledning her.  
  Anbefalet læsning
    Dobbeltkoblet liste i Java - Implementering og kodeeksempler  
  Java-liste - Sådan oprettes, initialiseres og bruges listen i Java  
  Java List Methods - Sort List, Indeholder, List Add, List Fjern  
  Binær søgealgoritme i Java - implementering og eksempler  
  Insertion Sort In Java - Insertion Sort Algorithm & Eksempler  
  Java-interface og abstrakt klasseundervisning med eksempler  
  Sammenkædet liste datastruktur i C ++ med illustration  
  Skjult liste til matrix og andre samlinger i Java