Propojený seznam v Javě - Implementace propojeného seznamu a příklady Java

linked list java linked list implementation java examples

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Vyberte Operační Systém Vyberte Program Projekce (Volitelně)

Popište Svůj Problém

Tento výukový program vysvětluje, co je datová struktura propojeného seznamu v Javě a jak vytvořit, inicializovat, implementovat, procházet, obrátit a třídit seznam propojený v jazyce Java:

V Javě je LinkedList datová struktura, která ukládá prvky na nesouvislé místo. Jedná se o lineární datovou strukturu.

Každá datová položka se nazývá „uzel“ a každý uzel má datovou část a část adresy. Část adresy uloží odkaz na další uzel v LinkedList.

=> Navštivte zde a prohlédněte si sérii školení Java pro všechny.

Propojený seznam v Javě

Co se naučíte:

LinkedList v Javě
Závěr
- Doporučené čtení

LinkedList v Javě

Níže je uvedeno obecné rozložení LinkedList:

obecné rozložení LinkedList

Jak je ukázáno ve výše uvedeném zobrazení LinkedList, každá položka v LinkedList je „Uzel“. Každý uzel má dvě části, první část ukládá data a druhá část má odkaz nebo ukazatel nebo adresu dalšího uzlu v LinkedList.

nejlepší bezplatný převaděč souborů pro Windows 10

Toto uspořádání je nezbytné, protože data v LinkedList jsou na rozdíl od polí uložena na nesouvislých místech.

„Hlava“ LinkedList je ukazatel, který obsahuje adresu prvního prvku v LinkedList. Poslední uzel v LinkedList je ocas. Jak je znázorněno na obrázku výše, adresní část posledního uzlu v LinkedList je nastavena na „Null“ označující konec LinkedList.

Výše uvedený diagram představuje „ Singly-linked List ”, Který ukládá adresu pouze dalšího uzlu v LinkedList.

Existuje další verze známá jako „ Dvojnásobně propojený seznam „Jehož každý uzel má tři části:

Adresa nebo odkaz nebo ukazatel na předchozí prvek v LinkedList.
Datová část
Adresa nebo odkaz nebo ukazatel na další prvek v LinkedList.

Předchozí adresa prvního prvku v LinkedList bude nastavena na Null, zatímco další ukazatel Last elementu v LinkedList je nastaven na Null.

Reprezentace dvojitě propojeného seznamu:

dvojnásobně propojený seznam

Jak je znázorněno ve výše uvedeném znázornění, každý uzel v dvojnásobně propojeném seznamu má ukazatele na jeho předchozí a následující uzel (tedy reprezentován bez šipek). Předchozí ukazatel prvního uzlu ukazuje na null, zatímco další ukazatel posledního uzlu ukazuje na null.

V tomto tutoriálu LinkedList se budeme zabývat většinou seznamem jednotlivě propojeným. O dvojnásobně propojeném seznamu budeme diskutovat v našem dalším kurzu.

Java LinkedList Class

V Javě je propojený seznam implementován pomocí „ Spojový seznam ”Třída. Tato třída patří do „ java.util ”Balíček. Třída LinkedList implementuje rozhraní List a Deque a dědí třídu AbstractList.

Níže je uvedena hierarchie tříd třídy LinkedList.

hierarchie tříd třídy LinkedList

Výše uvedený diagram ukazuje hierarchii třídy LinkedList. Jak je znázorněno, třída LinkedList implementuje rozhraní List a Deque.

Jak již bylo zmíněno, třída LinkedList je součástí „ java.util ”Balíček. Proto byste měli být schopni používat třídu LinkedList ve vašem programu zahrnutím jednoho z následujících příkazů do vašeho programu.

import java.util.*;

Nebo

import java.util.LinkedList;

Na základě výše uvedené hierarchie je tedy typická definice třídy LinkedList následující:

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

Níže jsou uvedeny některé vlastnosti třídy LinkedList, které byste si měli pamatovat:

Tato třída není synchronizována.
Umožňuje duplicitní hodnoty.
Zachová objednávku.
Jelikož prvky se nemusí pohybovat, manipulace s prvky v nich je rychlejší.
Tuto třídu lze použít k implementaci zásobníku, fronty a seznamu.

Jak vytvořit propojený seznam v Javě

Než přejdeme k vytvoření propojeného seznamu v Javě, pojďme nejprve probrat uzel propojeného seznamu v Javě.

Jak již bylo uvedeno, propojený seznam se skládá z uzlů. V Javě tedy můžeme představit LinkedList jako třídu s jeho uzlem jako samostatnou třídu. Proto tato třída bude mít odkaz na typ Node.

Toto je zobrazeno níže:

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

Chcete-li vytvořit objekt typu LinkedList, existují dva hlavní konstruktory takto:

# 1) LinkedList ()

Obecná syntaxe pro tento konstruktor je:

LinkedList linkedList = new LinkedList();

Výše uvedený příkaz vytvoří prázdný LinkedList.

Například,

LinkedList l_list = new LinkedList();

Tím se vytvoří prázdný propojený seznam s názvem l_list.

# 2) LinkedList (kolekce c)

Obecná syntaxe je:

LinkedList linkedList = new LinkedList (Collection c);

Výše uvedený příkaz vytvoří jako první prvky LinkedList s prvky z kolekce c.

Stejně jako ostatní datové struktury seznamu, které jsme již viděli, lze propojený seznam také inicializovat pomocí metody add, metody Arrays.asList () nebo pomocí konstruktoru s kolekcí jako argumentem.

Implementace propojeného seznamu v Javě

Níže je uveden jednoduchý příklad datové struktury LinkedList v Javě. V tomto příkladu implementace použijeme metodu add a metodu asList k inicializaci objektů 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); } }

Výstup:

Obsah prvního LinkedList: (10, 20, 30, 40, 50)
Obsah druhého LinkedList: (červená, zelená, modrá, azurová, purpurová)

implementace seznamu spojeného s výstupem

Výše uvedený program ukazuje vytvoření a inicializaci LinkedList. Nejprve vytvoříme LinkedList typu Integer a poskytneme pole celých čísel převedených do seznamu pomocí metody asList jako počáteční hodnoty pro LinkedList.

Dále vytvoříme prázdný LinkedList typu String a poté pomocí metody add přidáme hodnoty do LinkedList.

Nakonec zobrazíme oba objekty LinkedList jako řetězec.

Procházet / tisknout propojený seznam v Javě

Chcete-li tisknout obsah nebo provádět jakékoli operace s prvky LinkedList, musíte projít jeho prvky. Tyto metody jsme již viděli v našich předchozích výukových programech. V této části probereme příklady každého s ohledem na LinkedList.

Pomocí smyčky 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  Výstup: 
 LinkedList prvky využívající smyčku for: 
Červená Zelená Modrá
  
 Používání 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 + ' '); } } }  Výstup: 
 LinkedList prvky využívající smyčku forEach: 
Červená Zelená Modrá
  
 Používání Iterátoru
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() + ' '); } } }  Výstup: 
 Obsah propojeného seznamu: 
Červená Zelená Modrá Žlutá
jaký je nejlepší databázový software
  
 Metody LinkedList
 Třída LinkedList poskytuje API, které podporuje různé metody manipulace se seznamem Linked. Níže jsme uvedli metody v tabulce LinkedList API.
  Budeme diskutovat o hlavních operacích / metodách v následující části. 
   Metoda Prototyp Popis  
 
  Průhledná prázdnota clear () Odstraní všechny prvky ze seznamu.  
 Přidat boolean add (E e) Přidejte určený prvek do LinkedList  
  void add (int index, E element) Přidejte prvek na daný index v LinkedList  
  Přidat vše boolean addAll (kolekce c) Přidá prvky dané kolekce c na konec LinkedList.  
  boolean addAll (int index, kolekce c) Přidá prvky dané kolekce c na zadaný index v LinkedList  
  addFirst void addFirst (E e) Přidejte daný prvek jako první prvek do LinkedList.  
  přidatPoslední void addLast (E e) Přidejte daný prvek na konec seznamu.  
   Klonovat Klon objektu () Vytvoří mělkou kopii LinkedList  
  Obsahuje Boolean obsahuje (Objekt o) Zkontroluje, zda seznam obsahuje zadané prvky; pokud ano, vrátí se pravda.  
  sestupněIterátor Iterátor sestupněIterátor () Vrátí zpětně seřazený iterátor pro LinkedList.  
  Živel E prvek () Vrátí prvek v záhlaví seznamu.  
  Dostat E get (int index) Získá prvek na zadaném indexu.  
  getFirst E getFirst () Načte první prvek v LinkedList.  
  getLast E getLast () Načte poslední prvek v LinkedList.  
  indexOf Int indexOf (Objekt o) Najděte index prvního výskytu daných prvků v seznamu a vraťte index. -1, pokud prvek nebyl nalezen.  
  lastIndexOf Int lastIndexOf (objekt o) Vrátí pozici posledního výskytu daného prvku v LinkedList; -1, pokud daný prvek není k dispozici  
  listIterator ListIterator listIterator (int index) Vrátí listIterator ze zadaného indexu v propojeném seznamu.  
  Nabídka booleovská nabídka (E e) Přidá daný prvek jako poslední prvek (ocas) do LinkedList.  
  nabídka první Booleovská nabídka První (V e) Přidá daný prvek jako první prvek v LinkedList.  
  poslední nabídka Booleovská nabídkaPoslední (V e) Přidejte daný prvek e na konec LinkedList.  
  Nakoukni E nahlédnout () Vrátí hlavičku seznamu, aniž by ji odstranil.  
  nahlédnout Nejprve E peekFirst () Vrátí první prvek v seznamu. vrací null, pokud je seznam prázdný.  
  nahlédnoutPoslední E peekLast () Vrátí poslední prvek nebo null, pokud je seznam prázdný. Neodstraní prvek.  
  Hlasování E hlasování () Vrátí hlavičku LinkedList a také ji odebere.  
  hlasování E hlasování První () Vrátí a odstraní první prvek v seznamu; vrací null, pokud je seznam prázdný.  
  hlasováníposlední E hlasováníPoslední () Vrátí a odstraní poslední prvek v seznamu; vrací null, pokud je seznam prázdný.  
  Pop E pop () Vyskakuje prvek z reprezentace zásobníku LinkedList.  
  Tam Void push (E e) Vloží nebo vloží prvek do reprezentace zásobníku LinkedList.  
  Odstranit E odebrat () Odebere a vrátí záhlaví LinkedList.  
  E remove (int index) Odstraní prvek v daném indexu z LinkedList.  
  boolean remove (Objekt o) Odstraní první výskyt daného prvku z LinkedList.  
  removeFirst E removeFirst () Vrátí a odstraní první prvek ze seznamu.  
  removeFirstOccurence boolean removeFirstOccurrence (objekt o) Odstraní první výskyt daného prvku ze seznamu, když je seznam procházen od hlavy k ocasu.  
  removePoslední E removeLast () Vrátí poslední prvek v LinkedList a také jej odstraní.  
  removeLastOccurence boolean removeLastOccurrence (objekt o) Odebere poslední výskyt daného prvku z LinkedList při přechodu z hlavy do ocasu  
  Soubor Sada E (int index, prvek E) Nastaví daný prvek na daný index. Nahradí aktuální prvek novým.  
  Velikost Velikost int () Vrátí velikost nebo počet prvků v LinkedList  
  toArray Objekt () toArray () Převede LinkedList na pole obsahující všechny prvky seznamu ve správném pořadí  
  T () toArray (T () a) Převede LinkedList na pole s runtime typem, který je stejný jako argument a.  
 
 
  Níže uvedený program Java demonstruje různé metody, které jsme uvedli výše. 
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)); } } Výstup: 
 Propojený seznam: (A, B, C, D, G, E, F) 
Propojený seznam po přidání obsahu ArrayList: (A, B, C, D, G, E, F, H, I) 
Propojený seznam po odstranění: (C, D, E, F, H) 
Seznam neobsahuje prvek „G“ 
Velikost propojeného seznamu = 5 
Prvek vrácený funkcí get (): F 
Propojený seznam po změně: (C, D, E, J, H) 
Pole získané z propojeného seznamu: (C, D, E, J, H)
  
 Výše uvedený program demonstruje různé metody třídy LinkedList. Nejprve deklarujeme LinkedList typu String. Pak použijeme různé verze metody add jako add, andFirst, addLast, addAll atd. K naplnění LinkedList hodnotami.
 Zde můžeme přidat prvek přímo na konec seznamu nebo přidat prvek na určené místo v seznamu.
 Metodu addFirst také používáme k přidání prvku na začátek seznamu a metody addLast k přidání prvku na konec seznamu. Pak provedeme operace odebrání na LinkedList, jako remove, removeFirst, removeLast atd.
 Pro metodu remove můžeme buď určit prvek, který má být odstraněn, nebo můžeme určit index nebo pozici v LinkedList, na které má být prvek odstraněn. Metody removeFirst a removeLast odstraní první a poslední prvek v seznamu.
 Poté pomocí metody contains prohledáme seznam konkrétního prvku. Dále použijeme metodu size () k načtení velikosti nebo délky LinkedList. Pak použijeme metody get / set k načtení hodnoty u konkrétního indexu v seznamu a poté nahradíme hodnotu na zadané pozici v seznamu.
  Nakonec převedeme LinkedList na Array pomocí metody toArray. 
 Reverzně propojený seznam v Javě
 K obrácení propojeného seznamu v Javě používáme metodu „descendingIterator ()“, která vrací zpětný iterátor seznamu. Tento iterátor pak můžeme použít k procházení prvky seznamu a zobrazení.
  Níže uvedený program převrátí propojený seznam pomocí metody 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() + ' '); } } }  Výstup: 
 Propojený seznam: (Pune, Mumbai, Nagpur) 
Propojený seznam v opačném pořadí: 
Nagpur Bombaj Pune
  
 Ve výše uvedeném programu deklarujeme propojený seznam a poté jej vytiskneme. Pak získáme reverzní iterátor a pomocí něj projdeme seznam a zobrazíme každý prvek. Výstup zobrazuje propojený obsah seznamu, nejprve v pořadí, v jakém jsou přidány prvky, a potom výstup zobrazuje obsah v opačném pořadí.
 Třídit propojený seznam v Javě
 Objekty třídy LinkedList lze třídit pomocí metody Collections.sort (). Tato metoda poskytuje dvě verze s nebo bez použití komparátoru. Když je metoda Collections.sort () volána bez komparátoru, kolekce je tříděna v přirozeném pořadí.
 Když komparátor se používá s touto metodou, můžeme definovat naše vlastní kritéria řazení přepsáním metody compareTo.
  Níže uvedený program Java třídí LinkedList pomocí Collections.sort (). Zde řadíme pole pomocí přirozeného řazení i pomocí komparátoru. 
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); } } Výstup: 
 Původní LinkedList (bez řazení): (leden, únor, březen, duben, květen, červen) 
LinkedList (seřazeno v přirozeném pořadí): (duben, únor, leden, červen, březen, květen) 
LinkedList (seřazeno podle komparátoru): (duben, únor, leden, červen, březen, květen)
  
 Odebrat duplikáty
 Chcete-li odebrat duplikáty, musíte projít každý uzel a porovnat jej s dalším uzlem. Pokud jsou oba uzly stejné, přeskočíme jeden uzel a přejdeme k dalšímu.
 Tímto způsobem po procházení každého uzlu a zbavení se duplicitních uzlů získáme výsledný seznam, který je bez duplicitních prvků.
analýza hraničních hodnot a rozdělení ekvivalence
  Níže je uveden program Java pro odstranění duplikátů. 
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(); } }  Výstup: 
 Původní Linkedlist: 
1 1 2 3 5 2 1 1 
LinkedList po odstranění duplikátů: 
1 2 3 5
  
 Ve výše uvedeném programu máme vytvořenou třídu propojeného seznamu, abychom odstranili duplikáty. Máme také třídu, která definuje každý uzel. Jinými slovy, uzly v seznamu jsou objekty tohoto uzlu třídy. Máme metodu přidání uzlu do propojeného seznamu.
 Pak v metodě removeDuplicate projdeme každý uzel v propojeném seznamu počínaje od hlavy a porovnáme každý následující uzel pro duplikát. Pokud je nalezen duplikát, tento uzel přeskočíme a přejdeme k dalšímu uzlu.
 Tímto způsobem je ist vytvořen přeskočením duplicitních uzlů a změněný seznam je vytištěn pomocí metody print ().
 Kruhový propojený seznam v Javě
 Kruhový propojený seznam je seznam, který má svůj ocas nebo poslední uzel připojený zpět k hlavě nebo prvnímu uzlu.
  Níže uvedený diagram ukazuje kruhový propojený seznam v Javě. 
  
 Jak je znázorněno ve výše uvedeném diagramu, adresní část posledního uzlu nebo ocasu propojeného seznamu není nastavena na null. Místo toho ukazuje zpět na první uzel nebo hlavu seznamu, čímž vytvoří kruhový propojený seznam.
  Níže uvedený program implementuje kruhový propojený seznam, ve kterém musíme manipulovat s jednotlivými uzly propojeného seznamu. 
 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(); } }  Výstup: 
 Uzly kruhového propojeného seznamu: 
10 20 30 40
  
 Související seznamy Java 8
 Ačkoli v Javě 8 nejsou do třídy LinkedList přidány žádné další funkce, stále zavedla proudy pro manipulaci s daty.
  Níže uvedený program ukazuje použití proudu Java 8 k zobrazení 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); } } Výstup: 
 Obsah LinkedList: 
Síť 
Zelený 
Modrý 
Tyrkysová 
Purpurová
  
 Často kladené otázky
  Otázka č. 1) Kdy se propojený seznam používá v Javě? 
  Odpovědět: Jelikož je rychlejší než kolekce jako ArrayList v modifikačních operacích, měl by být používán v aplikacích, které vyžadují časté operace přidání / odstranění. U aplikací, které mají většinou data jen pro čtení, lze použít ArrayList nebo podobné kolekce.
  Otázka č. 2)  Co je ListNode? 
  Odpovědět: ListNode je základní třída spojená s propojeným seznamem v Javě a představuje informace spojené s jedním prvkem nebo uzlem. Každý ListNode se skládá z dat a ukazatele nebo odkazu na další prvek.
  Otázka č. 3)  Umožňuje propojený seznam nulové hodnoty? 
  Odpovědět: Ano, propojený seznam umožňuje libovolný počet hodnot null.
  Otázka č. 4)  Jaké jsou výhody propojeného seznamu? 
  Odpověď: Některé z výhod jsou: 
  Manipulační operace, jako je přidání, odstranění, jsou rychlejší.
 Není třeba předem přidělit paměť pro propojený seznam, což vede k efektivnímu využití paměti.
 Poskytuje rychlejší přístupový čas a bez dalších režijních nákladů na paměť a lze jej rozšiřovat v konstantním čase.
 Jedná se o dynamickou datovou strukturu
 Roste a zmenšuje se za běhu v závislosti na přidaných nebo odstraněných hodnotách.
 
  Otázka č. 5)  Jaké je použití propojeného seznamu? 
  Odpověď: Používá se většinou v následujících aplikacích: 
  Chcete-li implementovat funkci „zpět“ v softwaru, jako je MS-Word, Photoshop atd.
 Implementovat datové struktury, jako je zásobník a fronta.
 Můžeme také implementovat grafy pomocí propojeného seznamu.
 Pro hašování segmentů lze každý segment implementovat jako propojený seznam.
 
  Otázka č. 6)  Jaká jsou omezení propojeného seznamu? 
  Odpověď: Některá omezení jsou: 
  Díky dalšímu ukazateli, který drží odkaz na další prvek v každém uzlu, je využitá paměť mnohem více než pole.
 Jedná se o přísně sekvenčně přístupnou datovou strukturu, proto uzly propojeného seznamu musí být vždy čteny od začátku.
 Je obtížné jej posunout zpět, zejména seznamy, které jsou jednotlivě propojeny.
 Vzhledem k tomu, že uzly jsou uloženy na nesouvislých místech, může být čas potřebný pro přístup vysoký.
 
 Závěr
 V tomto kurzu jsme se naučili základní datovou strukturu propojeného seznamu. Poté jsme přešli na třídu java.util.LinkedList poskytovanou v Javě. Tuto třídu jsme probrali podrobně včetně jejích konstruktorů, metod atd.
 Také jsme diskutovali o některých speciálních operacích souvisejících s propojenými seznamy, jako je třídění, obrácení seznamu, odstraňování duplikátů, kruhový propojený seznam atd.
   V našem dalším kurzu se budeme zabývat konkrétními funkcemi dvojitě propojeného seznamu.  
  => Podívejte se na Kompletní průvodce tréninkem Java zde.  
  Doporučené čtení
    Dvojnásobně propojený seznam v Javě - příklady implementace a kódu  
  Seznam Java - Jak vytvořit, inicializovat a používat seznam v Javě  
  Metody seznamu Java - Řazení seznamu, Obsahuje, Přidat seznam, Seznam odebrat  
  Algoritmus binárního vyhledávání v Javě - implementace a příklady  
  Insertion Sort In Java - Alserith Sort Algorithm & examples  
  Výukový program pro rozhraní Java a abstrakt třídy s příklady  
  Propojená datová struktura seznamu v C ++ s ilustrací  
  Skrytý seznam do pole a další sbírky v Javě