Koblet liste i Java - Koblet listeimplementering og Java-eksempler

linked list java linked list implementation java examples

Prøv Instrumentet Vårt For Å Eliminere Problemer

Velg Operativsystemet Velg Et Projeksjonsprogram (Valgfritt)

Beskriv Problemet Ditt

Denne opplæringen forklarer hva som er en lenket datastruktur i Java og hvordan du oppretter, initialiserer, implementerer, krysser, reverserer og sorterer en Java-koblet liste:

I Java er en LinkedList en datastruktur som lagrer elementer på en ikke-sammenhengende plassering. Det er en lineær datastruktur.

Hvert dataelement kalles en ‘Node’ og hver node har en datadel og en adressedel. Adressedelen lagrer lenken til neste node i LinkedList.

=> Besøk her for å se Java Training Series for alle.

Koblet liste i Java

Hva du vil lære:

LinkedList I Java
Konklusjon
- Anbefalt lesing

LinkedList I Java

Nedenfor er den generelle utformingen av LinkedList:

generell layout av LinkedList

Som vist i ovenstående representasjon av LinkedList, er hvert element i LinkedList “Node”. Hver node har to deler, den første delen lagrer dataene og den andre delen har en referanse eller peker eller adresse til neste node i LinkedList.

c ++ stack datastruktur

Denne ordningen er nødvendig ettersom dataene i LinkedList er lagret på ikke-sammenhengende steder, i motsetning til Arrays.

'Hodet' til LinkedList er en peker som inneholder adressen til det første elementet i LinkedList. Den siste noden i LinkedList er halen. Som vist i figuren ovenfor er adressedelen til den siste noden i LinkedList satt til 'Null' som indikerer slutten på LinkedList.

Diagrammet ovenfor representerer en “ Enkeltkoblet liste ”Som lagrer adressen til bare neste node i LinkedList.

Det er en annen versjon kjent som “ Dobbeltkoblet liste ”Hvis node har tre deler:

Adresser eller referanse eller peker til forrige element i LinkedList.
Datadel
Adresser eller referanse eller peker til neste element i LinkedList.

Den forrige adressen til det første elementet i LinkedList vil bli satt til Null mens den neste pekeren til det siste elementet i LinkedList er satt til Null.

Representasjon av dobbeltkoblet liste:

dobbeltkoblet liste

Som vist i representasjonen ovenfor, har hver node i den dobbeltkoblede listen pekere til sin forrige og neste node (dermed representert uten piler). Den forrige pekeren til den første noden peker mot null, mens den neste pekeren til den siste noden peker mot null.

I denne LinkedList-opplæringen vil vi for det meste håndtere den enkeltkoblede listen. Vi vil diskutere den dobbeltkoblede listen i vår neste opplæring.

Java LinkedList-klasse

I Java er den koblede listen implementert av “ LinkedList ”Klasse. Denne klassen tilhører “ java.util ”Pakke. LinkedList-klassen implementerer grensesnittet List og Deque og arver klassen AbstractList.

Nedenfor er klassehierarkiet til LinkedList-klassen.

klassehierarki i LinkedList-klassen

Ovenstående diagram viser hierarkiet til LinkedList-klassen. Som vist implementerer LinkedList-klassen grensesnittet List og Deque.

Som allerede nevnt er LinkedList-klassen en del av “ java.util ”Pakke. Derfor bør du kunne bruke LinkedList-klassen i programmet ditt ved å inkludere en av følgende utsagn i programmet ditt.

import java.util.*;

Eller

import java.util.LinkedList;

Så basert på hierarkiet ovenfor, er en typisk definisjon av LinkedList-klassen som følger:

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

Enlisted nedenfor er noen av egenskapene til LinkedList-klassen du bør huske:

Denne klassen er ikke synkronisert.
Det tillater dupliserte verdier.
Beholder innsettingsrekkefølgen.
Siden det ikke er nødvendig å flytte elementer mens de beveger seg, er manipulasjonen av elementene i den raskere.
Denne klassen kan brukes til å implementere en stabel, kø og liste.

Hvordan lage en koblet liste i Java

Før vi går videre til å lage en koblet liste i Java, la oss først diskutere en koblet listeknute i Java.

Som allerede diskutert består en koblet liste av noder. Dermed i Java kan vi representere en LinkedList som en klasse med sin Node som en egen klasse. Derfor vil denne klassen ha en referanse til Node-typen.

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 å lage et objekt av typen LinkedList, er det to hovedkonstruktører som følger:

# 1) LinkedList ()

Den generelle syntaksen for denne konstruktøren er:

LinkedList linkedList = new LinkedList();

Ovennevnte uttalelse oppretter en tom LinkedList.

For eksempel,

LinkedList l_list = new LinkedList();

Dette vil opprette en tom koblet liste kalt l_list.

# 2) LinkedList (samling c)

Den generelle syntaksen er:

LinkedList linkedList = new LinkedList (Collection c);

Ovennevnte uttalelse oppretter en LinkedList med elementer fra samlingen c som de første elementene.

Som andre listedatastrukturer som vi allerede har sett, kan den koblede listen også initialiseres ved hjelp av add-metoden, Arrays.asList () -metoden, eller ved å bruke konstruktøren med samlingen som et argument.

Koblet listeimplementering i Java

Nedenfor er et enkelt eksempel på en LinkedList-datastruktur i Java. I dette eksempelet på implementering vil vi bruke add-metoden og asList-metoden til å initialisere LinkedList-objektene.

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

Produksjon:

Innholdet i første LinkedList: (10, 20, 30, 40, 50)
Innholdet i den andre LinkedList: (Rød, Grønn, Blå, Cyan, Magenta)

output-koblet listeimplementering

Ovennevnte program viser oppretting og initialisering av LinkedList. Først oppretter vi en LinkedList av typen Integer og gir en rekke Integers konvertert til liste ved hjelp av asList-metoden som startverdier for LinkedList.

Deretter oppretter vi en tom LinkedList av typen String, og deretter legger vi til verdier i LinkedList ved hjelp av add-metoden.

Til slutt viser vi begge LinkedList-objektene som en streng.

Travers / Skriv ut koblet liste i Java

For å skrive ut innholdet eller utføre operasjoner på elementene i LinkedList, må du krysse gjennom elementene. Vi har allerede sett disse metodene i våre tidligere opplæringsprogrammer. I denne delen vil vi diskutere eksemplene på hver med hensyn til LinkedList.

Bruker 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  Produksjon: 
 LinkedList-elementer som bruker for loop: 
Rød Grønn Blå
  
 Bruke 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 + ' '); } } }  Produksjon: 
 LinkedList-elementer som bruker forEach loop: 
Rød Grønn Blå
  
 Bruke 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() + ' '); } } }  Produksjon: 
 Innholdet i koblet liste: 
Rød Grønn Blå Gul
qa føre intervju spørsmål og svar pdf
  
 LinkedList Methods
 LinkedList-klassen gir API som støtter forskjellige metoder for å manipulere den koblede listen. Vi har tabellisert metodene i LinkedList API nedenfor.
  Vi vil diskutere hovedoperasjonene / metodene i det følgende avsnittet. 
   Metode Prototype Beskrivelse  
 
  Klar ugyldig klart () Sletter alle elementene fra listen.  
 Legg til boolsk tilsetning (E e) Legg til et spesifisert element i LinkedList  
  void add (int index, E element) Legg til element ved den gitte indeksen i LinkedList  
  Legg til alle boolsk addAll (samling c) Legger til elementene i gitt samling c på slutten av LinkedList.  
  boolsk addAll (int-indeks, samling c) Legger til elementene i gitt samling c ved den angitte indeksen i LinkedList  
  legg til første ugyldig addFirst (E e) Legg til det gitte elementet som det første elementet i LinkedList.  
  addLast ugyldig addLast (E e) Legg til det gitte elementet på slutten av listen.  
   Klon Objektklon () Lager en grunne kopi av LinkedList  
  Inneholder Boolsk inneholder (Objekt o) Sjekker om listen inneholder spesifiserte elementer; hvis ja returnerer sant.  
  synkendeIterator Iterator synkendeIterator () Returnerer en omvendt bestilt iterator for LinkedList.  
  Element E-element () Returnerer elementet øverst på listen.  
  Få E get (int-indeks) Får elementet til den angitte indeksen.  
  getFirst E getFirst () Henter det første elementet i LinkedList.  
  getLast E getLast () Henter det siste elementet i LinkedList.  
  oversikt over Int indexOf (Objekt o) Finn indeksen for den første forekomsten av de gitte elementene i listen, og returner indeksen. -1 hvis element ikke ble funnet.  
  lastIndexOf Int lastIndexOf (Objekt o) Returnerer posisjonen for den siste forekomsten av det gitte elementet i LinkedList; -1 hvis gitt element ikke er til stede  
  listIterator ListIterator listIterator (int index) Returnerer listIterator fra den angitte indeksen i den koblede listen.  
  By på boolsk tilbud (E e) Legger til det gitte elementet som det siste elementet (halen) i LinkedList.  
  tilbudFørst Boolsk tilbudFirst (E e) Legger til det gitte elementet som det første elementet i LinkedList.  
  tilbudSiste Boolsk tilbudLast (E e) Legg til gitt element e på slutten av LinkedList.  
  Titt E titt () Returnerer hodet på listen uten å fjerne den.  
  peekFørst E peekFirst () Returnerer det første elementet i listen. returnerer null hvis listen er tom.  
  peekLast E tittLast () Returnerer det siste elementet eller null hvis listen er tom. Det sletter ikke elementet.  
  avstemming E-avstemning () Returnerer hodet til LinkedList og fjerner det også.  
  meningsmålingFørst E pollFirst () Returnerer og sletter det første elementet i listen; returnerer null hvis listen er tom.  
  pollSiste E pollLast () Returnerer og sletter det siste elementet i listen; returnerer null hvis listen er tom.  
  Pop E pop () Popper elementet fra stakkrepresentasjonen til LinkedList.  
  Trykk Void push (E e) Skyver eller setter inn et element i stakkrepresentasjonen til LinkedList.  
  Ta vekk E fjerne () Fjerner og returnerer hodet til LinkedList.  
  E fjerne (int-indeks) Sletter elementet ved den gitte indeksen fra LinkedList.  
  boolsk fjerning (Objekt o) Sletter den første forekomsten av det gitte elementet fra LinkedList.  
  Fjern første E removeFirst () Returnerer og sletter det første elementet fra listen.  
  removeFirstOccurence boolsk removeFirstOccurrence (Objekt o) Sletter den første forekomsten av det gitte elementet fra listen når listen blir krysset fra hode til hale.  
  removeLast E removeLast () Returnerer det siste elementet i LinkedList og sletter det også.  
  removeLastOccurence boolean removeLastOccurrence (Objekt o) Fjerner den siste forekomsten av det gitte elementet fra LinkedList når den krysses fra hode til hale  
  Sett E-sett (int-indeks, E-element) Setter det gitte elementet ved den gitte indeksen. Erstatter det nåværende elementet med nytt.  
  Størrelse Int størrelse () Returnerer størrelse eller antall elementer i LinkedList  
  toArray Objekt () toArray () Konverterer LinkedList til en matrise som inneholder alle listeelementene i riktig rekkefølge  
  T () toArray (T () a) Konverterer LinkedList til en matrise med kjøretidstype som argument a.  
 
 
  Java-programmet nedenfor demonstrerer de forskjellige metodene vi listet opp 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)); } } Produksjon: 
 Koblet liste: (A, B, C, D, G, E, F) 
Koblet liste etter å ha lagt til ArrayList-innhold: (A, B, C, D, G, E, F, H, I) 
Koblet liste etter sletting: (C, D, E, F, H) 
Listen inneholder ikke elementet 'G' 
Størrelse på koblet liste = 5 
Element returnert av get (): F 
Koblet liste etter endring: (C, D, E, J, H) 
Array hentet fra lenket liste: (C, D, E, J, H)
  
 Ovennevnte program demonstrerer ulike metoder for LinkedList-klassen. Først erklærer vi en LinkedList av typen String. Deretter bruker vi forskjellige versjoner av add-metoden som add, andFirst, addLast, addAll, etc. for å fylle LinkedList med verdier.
 Her kan vi legge til elementet direkte på slutten av listen eller legge til elementet på en spesifisert posisjon i listen.
 Vi bruker også addFirst-metoden for å legge til et element i begynnelsen av listen og addLast for å legge til et element på slutten av listen. Deretter utfører vi fjernoperasjoner på LinkedList som remove, removeFirst, removeLast, etc.
 For fjerningsmetoden kan vi enten spesifisere elementet som skal fjernes, eller vi kan spesifisere indeksen eller posisjonen i den koblede listen der elementet skal fjernes. Metodene removeFirst og removeLast fjern henholdsvis det første og siste elementet i listen.
 Deretter søker vi i listen etter et bestemt element ved hjelp av metoden inneholder. Deretter bruker vi størrelsesmetoden () for å hente størrelsen eller lengden på LinkedList. Deretter bruker vi get / set-metoder for å hente verdien til en bestemt indeks i listen og deretter erstatte en verdi på en spesifisert posisjon i listen.
  Til slutt konverterer vi LinkedList til en Array ved hjelp av toArray-metoden. 
 Omvendt lenket liste i Java
 For å reversere en koblet liste i Java bruker vi metoden “descendingIterator ()” som returnerer en revers iterator for listen. Vi kan deretter bruke denne iteratoren til å krysse gjennom listen og vise elementene.
  Programmet nedenfor reverserer den koblede listen ved hjelp av descendingIterator () -metoden. 
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() + ' '); } } }  Produksjon: 
 Koblet liste: (Pune, Mumbai, Nagpur) 
Koblet liste i omvendt rekkefølge: 
Nagpur Mumbai Pune
  
 I programmet ovenfor erklærer vi en koblet liste og skriver den ut. Deretter får vi en omvendt iterator og går deretter gjennom listen ved å bruke den og viser hvert element. Utgangen viser det sammenkoblede listeinnholdet, først i den rekkefølgen elementene blir lagt til, og deretter viser utgangen innholdet i omvendt rekkefølge.
 Sorter en koblet liste i Java
 LinkedList-klasseobjekter kan sorteres ved hjelp av Collections.sort () -metoden. Denne metoden gir to versjoner med eller uten bruk av en komparator. Når Collections.sort () -metoden kalles uten komparator, sorteres samlingen i naturlig rekkefølge.
 Når komparator brukes med denne metoden, kan vi definere våre egne sorteringskriterier ved å overstyre metoden comparTo.
  Java-programmet nedenfor sorterer en LinkedList ved hjelp av Collections.sort (). Her sorterer vi matriser ved hjelp av naturlig bestilling i tillegg til å bruke 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); } } Produksjon: 
 Original LinkedList (usortert): (Jan, Feb, Mar, Apr, May, Jun) 
LinkedList (sortert i naturlig rekkefølge): (Apr, Feb, Jan, Jun, Mar, May) 
LinkedList (sortert ved hjelp av Comparator): (Apr, Feb, Jan, Jun, Mar, May)
  
 Fjern duplikater
 For å fjerne duplikater, må du krysse hver node og sammenligne den med neste node. Hvis begge noder er like, hopper vi over en node og går til den neste.
 På denne måten, etter å ha krysset hver eneste node og kvitt oss duplikatnoder, får vi den resulterende listen som er uten duplikatelementer.
  Nedenfor er et Java-program for å fjerne duplikater. 
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(); } }  Produksjon: 
 Opprinnelig koblet liste: 
1 1 2 3 5 2 1 1 
LinkedList etter fjerning av duplikater: 
1 2 3 5
  
 I det ovennevnte programmet har vi opprettet en koblet listeklasse for å fjerne duplikater. Vi har også en klasse for å definere hver node. Med andre ord, nodene i listen er objektene til denne klassenoden. Vi har en metode for å legge til noden i en koblet liste.
 Så i removeDuplicate-metoden krysser vi gjennom hver node i den koblede listen fra hodet og sammenligner hver påfølgende node for duplikatet. Hvis en duplikat blir funnet, hopper vi over den noden og fortsetter til neste node.
 På denne måten bygges ist ved å hoppe over de dupliserte nodene, og den endrede listen skrives ut ved hjelp av utskriftsmetoden ().
 Sirkulær koblet liste i Java
 En sirkulær koblet liste er en liste som har halen eller den siste noden koblet tilbake til hodet eller den første noden.
  Diagrammet nedenfor viser den sirkulære koblede listen i Java. 
  
 Som vist i diagrammet ovenfor er adressedelen til den siste noden eller halen på den koblede listen ikke satt til null. I stedet peker den tilbake til den første noden eller hodet på listen og danner dermed en sirkulær koblet liste.
  Programmet nedenfor implementerer en sirkulær koblet liste hvor vi må manipulere individuelle noder på den koblede listen. 
 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(); } }  Produksjon: 
 Rundkoblede liste noder: 
10 20 30 40
  
 Java 8 LinkedList
 Selv om det ikke er flere funksjoner lagt spesielt til i LinkedList-klassen i Java 8, introduserte den likevel strømmer for å manipulere data.
  Programmet nedenfor viser bruken av Java 8 stream for å 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); } } Produksjon: 
 Innholdet i LinkedList: 
Nett 
Grønn 
Blå 
Cyan 
Magenta
  
c ++ tegn til streng
 ofte stilte spørsmål
  Q # 1) Når brukes den koblede listen i Java? 
  Svar: Siden det er raskere enn samlinger som ArrayList i modifikasjonsoperasjoner, bør det brukes i applikasjoner som krever hyppige tilleggs- / slettingsoperasjoner. For applikasjoner som for det meste har skrivebeskyttet data, kan ArrayList eller lignende samlinger brukes.
  Q # 2)  Hva er ListNode? 
  Svar: En ListNode er en grunnleggende klasse tilknyttet en koblet liste i Java og representerer informasjon tilknyttet et enkelt element eller en node. Hver ListNode består av data og en peker eller referanse til neste element.
  Q # 3)  Tillater den koblede listen nullverdier? 
  Svar: Ja, den koblede listen tillater et hvilket som helst antall nullverdier.
  Q # 4)  Hva er fordelene med en koblet liste? 
  Svar: Noen av fordelene er: 
  Manipulasjonsoperasjoner som tillegg, sletting er raskere i det.
 Det er ikke behov for å forhåndsallokere minne til en koblet liste, og dermed resulterer det i effektiv minnebruk.
 Det gir raskere tilgangstid og uten ekstra overhead for minne, og kan utvides på konstant tid.
 Det er en dynamisk datastruktur
 Vokser og krymper ved kjøretid, avhengig av verdier som er lagt til eller slettet.
 
  Q # 5)  Hva er anvendelsen av den koblede listen? 
  Svar: Den brukes hovedsakelig i følgende applikasjoner: 
  Å implementere ‘angre’ funksjonalitet i programvare som MS-Word, Photoshop, etc.
 Å implementere datastrukturer som stabel og kø.
 Vi kan også implementere grafer ved hjelp av en koblet liste.
 For bøttehashing kan hver bøtte implementeres som en koblet liste.
 
  Q # 6)  Hva er begrensningene for en koblet liste? 
  Svar: Noen av begrensningene er: 
  Med en ekstra peker for å holde referansen til det neste elementet i hver node, er minnet som brukes mye mer enn matriser.
 Dette er en streng sekvensielt tilgjengelig datastruktur, derfor må noder på den koblede listen alltid leses fra begynnelsen.
 Det er vanskelig å krysse den bakover, spesielt de enkeltlinkede listene.
 Siden nodene er lagret på ikke-sammenhengende steder, kan tiden som kreves for tilgang være høy.
 
 Konklusjon
 I denne veiledningen har vi lært den grunnleggende datastrukturen for koblet liste. Så fortsatte vi java.util.LinkedList-klassen gitt i Java. Vi diskuterte denne klassen i detalj, inkludert konstruktører, metoder osv.
 Vi har også diskutert noen spesielle operasjoner relatert til koblede lister som sortering, reversering av en liste, fjerning av duplikater, sirkulær koblet liste, etc.
   I vår neste opplæring vil vi diskutere spesifikke funksjoner i den dobbeltkoblede listen.  
  => Sjekk den komplette Java-opplæringsguiden her.  
  Anbefalt lesing
    Dobbeltkoblet liste i Java - Implementering og kodeeksempler  
  Java List - Hvordan lage, initialisere og bruke listen i Java  
  Java-listemetoder - Sorteringsliste, Inneholder, Legg til liste, Fjern liste  
  Binær søkealgoritme i Java - implementering og eksempler  
  Insertion Sort In Java - Insertion Sort Algorithm & Eksempler  
  Java-grensesnitt og abstrakt klasseopplæring med eksempler  
  Koblet liste Datastruktur i C ++ med illustrasjon  
  Skjult liste for matrise og andre samlinger i Java