Rozhraní Seznam v Javě poskytuje způsob, jak uložit objednanou kolekci. Je to podřízené rozhraní Sbírka . Jedná se o uspořádanou kolekci objektů, ve které mohou být uloženy duplicitní hodnoty. Protože Seznam zachovává pořadí vložení, umožňuje poziční přístup a vkládání prvků.
Obsah
- Seznam rozhraní v Javě
- Deklarace rozhraní Java List
- Příklad Java List
- Operace v rozhraní seznamu Java
- Složitost rozhraní List v Javě
- Iterace přes List Interface v Javě
- Metody rozhraní seznamu
- Java List vs. Set
Seznam rozhraní v Javě
Rozhraní List se nachází v balíčku java.util a zdědí rozhraní Collection. Je to továrna rozhraní ListIterator. Prostřednictvím ListIteratoru můžeme seznam iterovat vpřed a vzad. Implementační třídy rozhraní List jsou ArrayList, LinkedList, Stack a Vector. ArrayList a LinkedList jsou široce používány v programování Java. Třída Vector je od Java 5 zastaralá.
List a ArrayList v Java Collection Framework
Deklarace rozhraní Java List
public interface List extends Collection ;>
Pojďme se podrobněji zabývat vytvářením objektů nebo instancí ve třídě List. Od té doby Seznam je rozhraní , nelze vytvořit objekty ze seznamu typů. Vždy potřebujeme třídu, která to implementuje Seznam za účelem vytvoření objektu. A také po zavedení Generika v Javě 1.5 je možné omezit typ objektu, který lze uložit do Seznamu. Stejně jako několik dalších uživatelsky definovaných „rozhraní“ implementovaných uživatelsky definovanými „třídami“, Seznam je „rozhraní“, implementované pomocí ArrayList třída, předdefinovaná v java.util balík.
Syntaxe Java List
Tento typ bezpečného seznamu lze definovat jako:
List list = new ArrayList ();>
Poznámka: Obj je typ objektu, který se má uložit do seznamu
Příklad Java List
Jáva
// Java program to Demonstrate List Interface> > // Importing all utility classes> import> java.util.*;> > // Main class> // ListDemo class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an object of List interface> >// implemented by the ArrayList class> >List l1 =>new> ArrayList();> > >// Adding elements to object of List interface> >// Custom inputs> > >l1.add(>0>,>1>);> >l1.add(>1>,>2>);> > >// Print the elements inside the object> >System.out.println(l1);> > >// Now creating another object of the List> >// interface implemented ArrayList class> >// Declaring object of integer type> >List l2 =>new> ArrayList();> > >// Again adding elements to object of List interface> >// Custom inputs> >l2.add(>1>);> >l2.add(>2>);> >l2.add(>3>);> > >// Will add list l2 from 1 index> >l1.addAll(>1>, l2);> > >System.out.println(l1);> > >// Removes element from index 1> >l1.remove(>1>);> > >// Printing the updated List 1> >System.out.println(l1);> > >// Prints element at index 3 in list 1> >// using get() method> >System.out.println(l1.get(>3>));> > >// Replace 0th element with 5> >// in List 1> >l1.set(>0>,>5>);> > >// Again printing the updated List 1> >System.out.println(l1);> >}> }> |
>
>Výstup
[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>
Nyní pojďme provádět různé operace pomocí List Interface, abychom tomu lépe porozuměli. Budeme diskutovat o následujících operacích uvedených níže a později o jejich implementaci prostřednictvím čistých kódů Java.
Operace v rozhraní seznamu Java
Protože List je rozhraní, lze jej použít pouze s třídou, která toto rozhraní implementuje. Nyní se podívejme, jak provést několik často používaných operací na Seznamu.
- Operace 1: Přidání prvků do třídy List pomocí metody add().
- Operace 2: Aktualizace prvků ve třídě List pomocí metody set().
- Operace 3: Hledání prvků pomocí metod indexOf(), lastIndexOf
- Operace 4: Odstranění prvků pomocí metody remove().
- Operace 5: Přístup k prvkům ve třídě List pomocí metody get().
- Operace 6: Kontrola, zda je prvek přítomen ve třídě List pomocí metody obsahuje().
Nyní pojďme diskutovat o operacích jednotlivě a implementovat totéž do kódu, abychom to lépe pochopili.
1. Přidání prvků do třídy List pomocí metoda add().
Chcete-li přidat prvek do seznamu, můžeme použít přidat() metoda. Tato metoda je přetížena prováděním více operací na základě různých parametrů.
Parametry: Chce to 2 parametry, a to:
- přidat (Objekt): Tato metoda se používá k přidání prvku na konec seznamu.
- add(int index, Object): Tato metoda se používá k přidání prvku do určitého indexu v seznamu
Příklad:
Jáva
jak zakázat vývojářský režim
// Java Program to Add Elements to a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >// Custom elements> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> >al.add(>1>,>'For'>);> > >// Print all the elements inside the> >// List interface object> >System.out.println(al);> >}> }> |
>
>Výstup
[Geeks, For, Geeks]>
2. Aktualizace prvků
Po přidání prvků, pokud chceme prvek změnit, lze to provést pomocí soubor() metoda. Protože List je indexovaný, na prvek, který chceme změnit, se odkazuje index prvku. Proto tato metoda bere index a aktualizovaný prvek, který je třeba vložit do tohoto indexu.
Příklad:
Jáva
// Java Program to Update Elements in a List> > // Importing utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface> >List al =>new> ArrayList();> > >// Adding elements to object of List class> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> >al.add(>1>,>'Geeks'>);> > >// Display theinitial elements in List> >System.out.println(>'Initial ArrayList '> + al);> > >// Setting (updating) element at 1st index> >// using set() method> >al.set(>1>,>'For'>);> > >// Print and display the updated List> >System.out.println(>'Updated ArrayList '> + al);> >}> }> |
>
>Výstup
Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>
3. Hledání prvků
Hledání prvků v rozhraní Seznam je běžnou operací v programování v Javě. Rozhraní seznamu poskytuje několik metod pro vyhledávání prvků, jako je např indexOf() , lastIndexOf() metody.
Metoda indexOf() vrací index prvního výskytu zadaného prvku v seznamu, zatímco metoda lastIndexOf() vrací index posledního výskytu zadaného prvku.
Parametry:
- indexOf(prvku): Vrátí index prvního výskytu zadaného prvku v seznamu nebo -1, pokud prvek nebyl nalezen
- lastIndexOf(element): Vrátí index posledního výskytu zadaného prvku v seznamu nebo -1, pokud prvek nebyl nalezen
Příklad:
Jáva
import> java.util.ArrayList;> import> java.util.List;> > public> class> ListExample {> >public> static> void> main(String[] args)> >{> >// create a list of integers> >List numbers =>new> ArrayList();> > >// add some integers to the list> >numbers.add(>1>);> >numbers.add(>2>);> >numbers.add(>3>);> >numbers.add(>2>);> > >// use indexOf() to find the first occurrence of an> >// element in the list> >int> index = numbers.indexOf(>2>);> >System.out.println(> >'The first occurrence of 2 is at index '> >+ index);> > >// use lastIndexOf() to find the last occurrence of> >// an element in the list> >int> lastIndex = numbers.lastIndexOf(>2>);> >System.out.println(> >'The last occurrence of 2 is at index '> >+ lastIndex);> >}> }> |
>
>Výstup
The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>
4. Odebírání prvků
Abychom odstranili prvek ze seznamu, můžeme použít odstranit() metoda. Tato metoda je přetížena prováděním více operací na základě různých parametrů. Oni jsou:
Parametry:
- odstranit (Objekt): Tato metoda se používá k jednoduchému odstranění objektu ze seznamu. Pokud existuje více takových objektů, pak se první výskyt objektu odstraní.
- remove(int index): Protože je seznam indexován, tato metoda přebírá celočíselnou hodnotu, která jednoduše odstraní prvek přítomný na tomto konkrétním indexu v seznamu. Po odstranění prvku se všechny prvky přesunou doleva, aby zaplnily prostor a indexy objektů se aktualizují.
Příklad:
Jáva
Java vylepšená smyčka
// Java Program to Remove Elements from a List> > // Importing List and ArrayList classes> // from java.util package> import> java.util.ArrayList;> import> java.util.List;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> > >// Creating List class object> >List al =>new> ArrayList();> > >// Adding elements to the object> >// Custom inputs> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> > >// Adding For at 1st indexes> >al.add(>1>,>'For'>);> > >// Print the initialArrayList> >System.out.println(>'Initial ArrayList '> + al);> > >// Now remove element from the above list> >// present at 1st index> >al.remove(>1>);> > >// Print the List after removal of element> >System.out.println(>'After the Index Removal '> + al);> > >// Now remove the current object from the updated> >// List> >al.remove(>'Geeks'>);> > >// Finally print the updated List now> >System.out.println(>'After the Object Removal '> >+ al);> >}> }> |
>
>Výstup
Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>
5. Přístup k prvkům
Pro přístup k prvku v seznamu můžeme použít dostat() metoda, která vrací prvek na zadaném indexu
Parametry:
get(int index): Tato metoda vrací prvek na zadaném indexu v seznamu.
Příklad:
Jáva
// Java Program to Access Elements of a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >al.add(>'Geeks'>);> >al.add(>'For'>);> >al.add(>'Geeks'>);> > >// Accessing elements using get() method> >String first = al.get(>0>);> >String second = al.get(>1>);> >String third = al.get(>2>);> > >// Printing all the elements inside the> >// List interface object> >System.out.println(first);> >System.out.println(second);> >System.out.println(third);> >System.out.println(al);> >}> }> |
>
>Výstup
Geeks For Geeks [Geeks, For, Geeks]>
6. Kontrola, zda je prvek přítomen v seznamu
Abychom zkontrolovali, zda je prvek v seznamu přítomen, můžeme použít obsahuje() metoda. Tato metoda vrátí hodnotu true, pokud je zadaný prvek v seznamu přítomen, jinak vrátí hodnotu false.
Parametry:
obsahuje(Objekt): Tato metoda přebírá jeden parametr, objekt, který má být zkontrolován, pokud je přítomen v seznamu.
Příklad:
Jáva
// Java Program to Check if an Element is Present in a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >al.add(>'Geeks'>);> >al.add(>'For'>);> >al.add(>'Geeks'>);> > >// Checking if element is present using contains()> >// method> >boolean> isPresent = al.contains(>'Geeks'>);> > >// Printing the result> >System.out.println(>'Is Geeks present in the list? '> >+ isPresent);> >}> }> |
>
>Výstup
Is Geeks present in the list? true>
Složitost rozhraní List v Javě
| Úkon | Časová složitost | Vesmírná složitost b plus strom |
|---|---|---|
| Přidání prvku do rozhraní seznamu | O(1) | O(1) |
| Odebrat prvek z rozhraní seznamu | NA) | NA) |
| Nahradit prvek v rozhraní seznamu | NA) | NA) |
| Rozhraní seznamu procházení | NA) | NA) |
Iterace přes List Interface v Javě
Doposud máme velmi malou vstupní velikost a operace provádíme ručně pro každou entitu. Nyní pojďme diskutovat o různých způsobech, jak můžeme iterovat seznam, aby fungovaly pro větší ukázkovou sadu.
Metody: Seznam lze iterovat několika způsoby. Nejznámější způsoby jsou pomocí základní pro smyčku v kombinaci s a metoda get(). získat prvek na konkrétním indexu a pokročilé pro smyčku .
Příklad:
Jáva
// Java program to Iterate the Elements> // in an ArrayList> > // Importing java utility classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// main driver method> >public> static> void> main(String args[])> >{> >// Creating an empty Arraylist of string type> >List al =>new> ArrayList();> > >// Adding elements to above object of ArrayList> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> > >// Adding element at specified position> >// inside list object> >al.add(>1>,>'For'>);> > >// Using for loop for iteration> >for> (>int> i =>0>; i // Using get() method to // access particular element System.out.print(al.get(i) + ' '); } // New line for better readability System.out.println(); // Using for-each loop for iteration for (String str : al) // Printing all the elements // which was inside object System.out.print(str + ' '); } }> |
>
>Výstup
Geeks For Geeks Geeks For Geeks>
Metody rozhraní seznamu
Protože hlavní koncept různých typů seznamů je stejný, rozhraní seznamu obsahuje následující metody:
| Metoda | Popis |
|---|---|
| add(int index, prvek) | Tato metoda se používá s rozhraním Java List Interface k přidání prvku do určitého indexu v seznamu. Když je předán jeden parametr, jednoduše přidá prvek na konec seznamu. |
| addAll(int index, kolekce kolekce) | Tato metoda se používá s rozhraním List v Javě k přidání všech prvků v dané kolekci do seznamu. Když je předán jeden parametr, přidá všechny prvky dané kolekce na konec seznamu. |
| velikost() | Tato metoda se používá s rozhraním Java List Interface k vrácení velikosti seznamu. |
| Průhledná() | Tato metoda se používá k odstranění všech prvků v seznamu. Odkaz na vytvořený seznam je však stále uložen. |
| odstranit (int index) | Tato metoda odebere prvek ze zadaného indexu. Následující prvky (pokud existují) posune doleva a sníží jejich indexy o 1. |
| odstranit (prvek) | Tato metoda se používá s rozhraním Java List Interface k odstranění prvního výskytu daného prvku v seznamu. |
| get(int index) | Tato metoda vrací prvky na zadaném indexu. |
| set(int index, prvek) | Tato metoda nahradí prvky na daném indexu novým prvkem. Tato funkce vrací prvek, který byl právě nahrazen novým prvkem. |
| indexOf(prvek) | Tato metoda vrací první výskyt daného prvku resp -1 pokud prvek není v seznamu přítomen. |
| lastIndexOf(prvek) | Tato metoda vrací poslední výskyt daného prvku resp -1 pokud prvek není v seznamu přítomen. |
| rovná se (prvek) | Tato metoda se používá s rozhraním Java List Interface k porovnání rovnosti daného prvku s prvky seznamu. |
| hashCode() | Tato metoda se používá s rozhraním List v Javě k vrácení hodnoty hashcode daného seznamu. |
| je prázdný() | Tato metoda se používá s rozhraním Java List Interface ke kontrole, zda je seznam prázdný nebo ne. Vrací hodnotu true, pokud je seznam prázdný, v opačném případě vrací hodnotu false. |
| obsahuje (prvek) | Tato metoda se používá s rozhraním List v Javě ke kontrole, zda seznam obsahuje daný prvek nebo ne. Vrací hodnotu true, pokud seznam obsahuje prvek. |
| obsahuje vše (kolekce kolekce) | Tato metoda se používá s rozhraním Java List Interface ke kontrole, zda seznam obsahuje všechny kolekce prvků. |
| řazení (komparátor) | Tato metoda se používá s rozhraním List v Javě k řazení prvků seznamu na základě daného srovnávač . |
Java List vs. Set
Rozhraní seznamu i rozhraní Set dědí rozhraní kolekce. Mezi nimi však existují určité rozdíly.
| Seznam | Soubor |
|---|---|
| Seznam je uspořádaná sekvence. | Sada je neuspořádaná sekvence. |
| Seznam umožňuje duplicitní prvky | Sada nepovoluje duplicitní prvky. |
| K prvkům lze přistupovat podle jejich polohy. | Pozice přístup k prvkům není povolen. |
| Lze uložit více nulových prvků. | Prvek null lze uložit pouze jednou. |
| Implementace seznamu jsou ArrayList, LinkedList, Vector, Stack | Implementace sady jsou HashSet, LinkedHashSet. |
Asociace tříd s rozhraním Java List
Nyní pojďme diskutovat o třídách, které implementují rozhraní seznamu, pro které se nejprve podívejte na níže uvedenou obrazovou reprezentaci, abyste lépe porozuměli rozhraní seznamu. Je to takto:
AbstractList , CopyOnWriteArrayList a AbstractSequentialList jsou třídy, které implementují rozhraní List. V každé ze zmíněných tříd je implementována samostatná funkcionalita. Jsou následující:
- AbstractList: Tato třída se používá k implementaci nemodifikovatelného seznamu, pro který je potřeba pouze rozšířit tuto třídu AbstractList a implementovat pouze dostat() a velikost() metody.
- CopyOnWriteArrayList: Tato třída implementuje rozhraní seznamu. Jedná se o vylepšenou verzi ArrayList ve kterém jsou všechny úpravy (přidat, nastavit, odebrat atd.) implementovány vytvořením nové kopie seznamu.
- AbstractSequentialList: Tato třída implementuje Rozhraní sběru a třída AbstractCollection. Tato třída se používá k implementaci nemodifikovatelného seznamu, pro který je potřeba pouze rozšířit tuto třídu AbstractList a implementovat pouze dostat() a velikost() metody.
Budeme postupovat tímto způsobem.
- ArrayList
- Vektor
- Zásobník
- Spojový seznam
Proberme je postupně a implementujme totéž, abychom zjistili, jak fungují třídy s rozhraním Seznam.
1. ArrayList
ArrayList třída, která je implementována v rámci kolekce, nám poskytuje dynamická pole v Javě. Může to být pomalejší než standardní pole, ale může být užitečné v programech, kde je potřeba spousta manipulace s polem. Podívejme se, jak pomocí této třídy vytvořit objekt seznamu.
Příklad:
Jáva
// Java program to demonstrate the> // creation of list object using the> // ArrayList class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of ArrayList> >int> n =>5>;> > >// Declaring the List with initial size n> >List arrli =>new> ArrayList(n);> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >arrli.add(i);> > >// Printing elements> >System.out.println(arrli);> > >// Remove element at index 3> >arrli.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(arrli);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(arrli.get(i) + ' '); } }> |
>
>
jak vymyslel školuVýstup
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
2. Vektor
Vector je třída, která je implementována v rámci kolekce a implementuje rozšiřitelné pole objektů. Vector implementuje dynamické pole, což znamená, že může růst nebo zmenšovat podle potřeby. Stejně jako pole obsahuje komponenty, ke kterým lze přistupovat pomocí celočíselného indexu. Vektory v podstatě spadají do starších tříd, ale nyní jsou plně kompatibilní s kolekcemi. Podívejme se, jak pomocí této třídy vytvořit objekt seznamu.
kali linuxový terminál
Příklad:
Jáva
// Java program to demonstrate the> // creation of list object using the> // Vector class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the vector> >int> n =>5>;> > >// Declaring the List with initial size n> >List v =>new> Vector(n);> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >v.add(i);> > >// Printing elements> >System.out.println(v);> > >// Remove element at index 3> >v.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(v);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(v.get(i) + ' '); } }> |
>
>Výstup
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
3. Zásobník
Stack je třída, která je implementována v rámci kolekce a rozšiřuje modely vektorových tříd a implementuje Příklad:
Jáva
Příklad:Jáva
// Java program to demonstrate the> // creation of list object using the> // Stack class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the stack> >int> n =>5>;> > >// Declaring the List> >List s =>new> Stack();> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >s.add(i);> > >// Printing elements> >System.out.println(s);> > >// Remove element at index 3> >s.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(s);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(s.get(i) + ' '); } }> |
>
>Výstup
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
4. LinkedList
Příklad:
Jáva
LinkedList je třída, která je implementována v rámci kolekce, která neodmyslitelně implementuje Příklad:Jáva
Příklad:Jáva
// Java program to demonstrate the> // creation of list object using the> // LinkedList class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the LinkedList> >int> n =>5>;> > >// Declaring the List with initial size n> >List ll =>new> LinkedList();> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >ll.add(i);> > >// Printing elements> >System.out.println(ll);> > >// Remove element at index 3> >ll.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(ll);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(ll.get(i) + ' '); } }> |
>
>Výstup
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>