De Lijst-interface in Java biedt een manier om de geordende verzameling op te slaan. Het is een onderliggende interface van Verzameling . Het is een geordende verzameling objecten waarin dubbele waarden kunnen worden opgeslagen. Omdat List de invoegvolgorde behoudt, is positionele toegang en invoeging van elementen mogelijk.
Inhoudsopgave
- Lijstinterface in Java
- Verklaring van Java-lijstinterface
- Voorbeeld van Java-lijst
- Bewerkingen in een Java-lijstinterface
- Complexiteit van de lijstinterface in Java
- Itereren via de lijstinterface in Java
- Methoden van de lijstinterface
- Java-lijst versus set
Lijstinterface in Java
De List-interface bevindt zich in het java.util-pakket en neemt de Collection-interface over. Het is een fabriek van de ListIterator-interface. Via de ListIterator kunnen we de lijst in voorwaartse en achterwaartse richting herhalen. De implementatieklassen van de List-interface zijn ArrayList, LinkedList, Stack en Vector. ArrayList en LinkedList worden veel gebruikt in Java-programmering. De klasse Vector is verouderd sinds Java 5.
Lijst en ArrayList in Java Collection Framework
Verklaring van Java-lijstinterface
public interface List extends Collection ;>
Laten we dieper ingaan op het maken van objecten of instanties in een List-klasse. Sinds Lijst is een koppel , kunnen er geen objecten van het type lijst worden gemaakt. We hebben altijd een klasse nodig die dit implementeert Lijst om een object te maken. En ook, na de introductie van Merkloos product in Java 1.5 is het mogelijk om het type object dat in de lijst kan worden opgeslagen te beperken. Net als verschillende andere door de gebruiker gedefinieerde ‘interfaces’ geïmplementeerd door door de gebruiker gedefinieerde ‘klassen’, Lijst is een ‘interface’, geïmplementeerd door de ArrayLijst klasse, vooraf gedefinieerd in java.util pakket.
Syntaxis van Java-lijst
Dit type veilige lijst kan als volgt worden gedefinieerd:
List list = new ArrayList ();>
Opmerking: Obj is het type object dat in Lijst moet worden opgeslagen
Voorbeeld van Java-lijst
Java
// 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);> >}> }> |
>
>Uitvoer
[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>
Laten we nu verschillende bewerkingen uitvoeren met behulp van de Lijstinterface om er een beter begrip van te krijgen. We zullen de volgende hieronder genoemde bewerkingen bespreken en deze later implementeren via schone Java-codes.
Bewerkingen in een Java-lijstinterface
Omdat List een interface is, kan deze alleen worden gebruikt met een klasse die deze interface implementeert. Laten we nu eens kijken hoe we enkele veelgebruikte bewerkingen in de lijst kunnen uitvoeren.
- Operatie 1: Elementen toevoegen aan de List-klasse met behulp van de add()-methode
- Operatie 2: Elementen in de klasse List bijwerken met behulp van de set()-methode
- Operatie 3: Zoeken naar elementen met behulp van de methoden indexOf(), lastIndexOf
- Operatie 4: Elementen verwijderen met behulp van de methode remove().
- Operatie 5: Toegang tot elementen in de klasse List met behulp van de get()-methode
- Operatie 6: Controleren of een element aanwezig is in de klasse List met behulp van de methode contain().
Laten we nu de bewerkingen afzonderlijk bespreken en deze in de code implementeren om er meer grip op te krijgen.
1. Elementen toevoegen aan de List-klasse met behulp van add() methode
Om een element aan de lijst toe te voegen, kunnen we de toevoegen() methode. Deze methode is overbelast om meerdere bewerkingen uit te voeren op basis van verschillende parameters.
Parameters: Er zijn 2 parameters nodig, namelijk:
- toevoegen(Object): Deze methode wordt gebruikt om een element aan het einde van de lijst toe te voegen.
- add(int-index, Object): Deze methode wordt gebruikt om een element toe te voegen aan een specifieke index in de lijst
Voorbeeld:
Java
parafraseer indien door Rudyard Kipling
// 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);> >}> }> |
>
>Uitvoer
[Geeks, For, Geeks]>
2. Elementen bijwerken
Als we na het toevoegen van de elementen het element willen wijzigen, kan dit worden gedaan met behulp van de set() methode. Omdat Lijst is geïndexeerd, wordt naar het element dat we willen wijzigen verwezen door de index van het element. Daarom gebruikt deze methode een index en het bijgewerkte element dat in die index moet worden ingevoegd.
Voorbeeld:
Java
// 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);> >}> }> |
>
>Uitvoer
Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>
3. Zoeken naar elementen
Zoeken naar elementen in de Lijst-interface is een gebruikelijke handeling bij het programmeren in Java. De Lijst-interface biedt verschillende methoden om naar elementen te zoeken, zoals de index van() , laatsteIndexOf() methoden.
De methode indexOf() retourneert de index van de eerste keer dat een opgegeven element in de lijst voorkomt, terwijl de methode lastIndexOf() de index retourneert van de laatste keer dat een opgegeven element voorkomt.
Parameters:
- indexVan(element): Retourneert de index van de eerste keer dat het opgegeven element in de lijst voorkomt, of -1 als het element niet is gevonden
- laatsteIndexOf(element): Retourneert de index van de laatste keer dat het opgegeven element in de lijst voorkomt, of -1 als het element niet is gevonden
Voorbeeld:
Java
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);> >}> }> |
>
>Uitvoer
The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>
4. Elementen verwijderen
Om een element uit een lijst te verwijderen, kunnen we de verwijderen() methode. Deze methode is overbelast om meerdere bewerkingen uit te voeren op basis van verschillende parameters. Zij zijn:
Parameters:
- verwijder(Object): Deze methode wordt gebruikt om eenvoudig een object uit de lijst te verwijderen. Als er meerdere van dergelijke objecten zijn, wordt het eerste exemplaar van het object verwijderd.
- verwijder(int index): Omdat een lijst is geïndexeerd, neemt deze methode een geheel getal, waardoor eenvoudigweg het element dat aanwezig is in die specifieke index in de lijst wordt verwijderd. Na het verwijderen van het element worden alle elementen naar links verplaatst om de ruimte te vullen en worden de indexen van de objecten bijgewerkt.
Voorbeeld:
Java
omkerende tekenreeks java
// 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);> >}> }> |
>
>Uitvoer
Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>
5. Toegang tot elementen
Om toegang te krijgen tot een element in de lijst, kunnen we de krijgen() methode, die het element retourneert op de opgegeven index
Parameters:
get(int index): Deze methode retourneert het element op de opgegeven index in de lijst.
Voorbeeld:
Java
// 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);> >}> }> |
>
>Uitvoer
Geeks For Geeks [Geeks, For, Geeks]>
6. Controleren of een element aanwezig is in de lijst
Om te controleren of een element in de lijst aanwezig is, kunnen we de bevat() methode. Deze methode retourneert true als het opgegeven element aanwezig is in de lijst, anders retourneert deze false.
Parameters:
bevat(Object): Deze methode gebruikt één enkele parameter: het object dat moet worden gecontroleerd als het aanwezig is in de lijst.
Voorbeeld:
Java
Java-datum nu
// 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);> >}> }> |
>
>Uitvoer
Is Geeks present in the list? true>
Complexiteit van de lijstinterface in Java
| Operatie | Tijdcomplexiteit | Ruimtecomplexiteit |
|---|---|---|
| Element toevoegen aan lijstinterface | O(1) | O(1) |
| Element verwijderen uit lijstinterface | OP) | OP) |
| Vervang element in lijstinterface | OP) | OP) |
| Lijstinterface doorlopen | OP) | OP) |
Itereren via de lijstinterface in Java
Tot nu toe hebben we een zeer kleine invoergrootte en voeren we bewerkingen handmatig uit voor elke entiteit. Laten we nu verschillende manieren bespreken waarmee we de lijst kunnen herhalen om ze werkend te krijgen voor een grotere voorbeeldset.
Methoden: Er zijn meerdere manieren om door de lijst te bladeren. De bekendste manieren zijn door gebruik te maken van de basis for loop in combinatie met een get() methode om het element op een specifieke index te krijgen en de ging vooruit voor een lus .
Voorbeeld:
Java
// 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 + ' '); } }> |
>
>Uitvoer
Geeks For Geeks Geeks For Geeks>
Methoden van de lijstinterface
Omdat het hoofdconcept achter de verschillende soorten lijsten hetzelfde is, bevat de lijstinterface de volgende methoden:
| Methode | Beschrijving |
|---|---|
| add(int index, element) | Deze methode wordt gebruikt met Java List Interface om een element toe te voegen aan een bepaalde index in de lijst. Wanneer een enkele parameter wordt doorgegeven, wordt eenvoudigweg het element aan het einde van de lijst toegevoegd. |
| addAll(int index, Verzamelingverzameling) | Deze methode wordt gebruikt met List Interface in Java om alle elementen in de gegeven verzameling aan de lijst toe te voegen. Wanneer een enkele parameter wordt doorgegeven, worden alle elementen van de gegeven verzameling aan het einde van de lijst toegevoegd. |
| maat() | Deze methode wordt gebruikt met Java List Interface om de grootte van de lijst te retourneren. |
| duidelijk() | Deze methode wordt gebruikt om alle elementen in de lijst te verwijderen. De referentie van de gemaakte lijst wordt echter nog steeds opgeslagen. |
| verwijder(int index) | Deze methode verwijdert een element uit de opgegeven index. Het verschuift de daaropvolgende elementen (indien aanwezig) naar links en verlaagt hun indexen met 1. |
| verwijder(element) | Deze methode wordt gebruikt met Java List Interface om de eerste keer dat het gegeven element in de lijst voorkomt, te verwijderen. |
| get(int-index) | Deze methode retourneert elementen op de opgegeven index. |
| set(int index, element) | Deze methode vervangt elementen op een bepaalde index door het nieuwe element. Deze functie retourneert het element dat zojuist is vervangen door een nieuw element. |
| indexOf(element) | Deze methode retourneert de eerste keer dat het gegeven element voorkomt of -1 als het element niet in de lijst voorkomt. |
| laatsteIndexOf(element) | Deze methode retourneert de laatste keer dat het gegeven element voorkomt of -1 als het element niet in de lijst voorkomt. |
| is gelijk aan(element) | Deze methode wordt gebruikt met Java List Interface om de gelijkheid van het gegeven element met de elementen van de lijst te vergelijken. |
| hashCode() | Deze methode wordt gebruikt met List Interface in Java om de hashcodewaarde van de gegeven lijst te retourneren. |
| is leeg() | Deze methode wordt gebruikt met Java List Interface om te controleren of de lijst leeg is of niet. Het retourneert waar als de lijst leeg is, anders onwaar. |
| bevat(element) | Deze methode wordt gebruikt met List Interface in Java om te controleren of de lijst het gegeven element bevat of niet. Het retourneert true als de lijst het element bevat. |
| bevatAll(collectieverzameling) | Deze methode wordt gebruikt met Java List Interface om te controleren of de lijst de volledige verzameling elementen bevat. |
| sort(vergelijkingsvergelijking) | Deze methode wordt gebruikt met List Interface in Java om de elementen van de lijst te sorteren op basis van het gegeven comparator . |
Java-lijst versus set
Zowel de List-interface als de Set-interface nemen de Collection-interface over. Er bestaan echter enkele verschillen tussen hen.
| Lijst | Set |
|---|---|
| De lijst is een geordende reeks. | De Set is een ongeordende reeks. |
| Lijst staat dubbele elementen toe | Set staat geen dubbele elementen toe. |
| Elementen zijn toegankelijk op basis van hun positie. | Positietoegang tot elementen is niet toegestaan. |
| Er kunnen meerdere nulelementen worden opgeslagen. | Het nulelement kan slechts één keer worden opgeslagen. |
| Lijstimplementaties zijn ArrayList, LinkedList, Vector, Stack | Set-implementaties zijn HashSet, LinkedHashSet. |
Klassenassociatie met een Java-lijstinterface
Laten we nu de klassen bespreken die de Lijstinterface implementeren, waarvoor we eerst naar de onderstaande afbeelding verwijzen om een beter begrip van de Lijstinterface te krijgen. Het is als volgt:
SamenvattingLijst , CopyOnWriteArrayList , en de SamenvattingSequentiëleLijst zijn de klassen die de List-interface implementeren. In elk van de genoemde klassen is een aparte functionaliteit geïmplementeerd. Ze zijn als volgt:
- SamenvattingLijst: Deze klasse wordt gebruikt om een niet-wijzigbare lijst te implementeren, waarvoor men alleen deze AbstractList-klasse hoeft uit te breiden en alleen de krijgen() en de maat() methoden.
- CopyOnWriteArrayLijst: Deze klasse implementeert de lijstinterface. Het is een verbeterde versie van ArrayLijst waarin alle wijzigingen (toevoegen, instellen, verwijderen, enz.) worden geïmplementeerd door een nieuwe kopie van de lijst te maken.
- SamenvattingSequentiëleLijst: Deze klasse implementeert de Verzamelinterface en de klasse AbstractCollection. Deze klasse wordt gebruikt om een niet-wijzigbare lijst te implementeren, waarvoor men alleen deze AbstractList-klasse hoeft uit te breiden en alleen de krijgen() en de maat() methoden.
Wij gaan op deze manier verder.
- ArrayLijst
- Vector
- Stapel
- GelinkteLijst
Laten we ze opeenvolgend bespreken en hetzelfde implementeren om de werking van de klassen met de List-interface te achterhalen.
1. ArrayLijst
Een ArrayList klasse die is geïmplementeerd in het verzamelframework, biedt ons dynamische arrays in Java. Hoewel het langzamer kan zijn dan standaardarrays, kan het nuttig zijn in programma's waarbij veel manipulatie in de array nodig is. Laten we eens kijken hoe we met deze klasse een lijstobject kunnen maken.
Voorbeeld:
voetnoten afwaardering
Java
// 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) + ' '); } }> |
>
>Uitvoer
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
2. Vector
Vector is een klasse die is geïmplementeerd in het verzamelingsframework en een groeiende reeks objecten implementeert. Vector implementeert een dynamische array, wat betekent dat deze naar behoefte kan groeien of krimpen. Net als een array bevat het componenten die toegankelijk zijn via een gehele index. Vectoren vallen in principe in oudere klassen, maar zijn nu volledig compatibel met collecties. Laten we eens kijken hoe we met deze klasse een lijstobject kunnen maken.
Voorbeeld:
Java
// 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) + ' '); } }> |
>
>Uitvoer
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
3. Stapel
Stack is een klasse die is geïmplementeerd in het verzamelingsframework en de vectorklassemodellen uitbreidt en implementeert Voorbeeld:
Java
Voorbeeld:Java
// 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) + ' '); } }> |
>
>Uitvoer
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
4. LinkedLijst
Voorbeeld:
Java
LinkedList is een klasse die is geïmplementeerd in het verzamelframework dat inherent de Voorbeeld:Java
Voorbeeld:Java
wat is jQuery
// 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) + ' '); } }> |
>
>Uitvoer
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>