Listegrænsefladen i Java giver mulighed for at gemme den bestilte samling. Det er en børnegrænseflade af Kollektion . Det er en ordnet samling af objekter, hvor duplikerede værdier kan gemmes. Da List bevarer indsættelsesrækkefølgen, tillader den positionsadgang og indsættelse af elementer.
Indholdsfortegnelse
- Listegrænseflade i Java
- Erklæring af Java List Interface
- Eksempel på Java List
- Operationer i en Java List Interface
- Kompleksiteten af listegrænseflade i Java
- Iteration over List Interface i Java
- Metoder til listegrænsefladen
- Java List vs Set
Listegrænseflade i Java
Listegrænsefladen findes i pakken java.util og arver samlingsgrænsefladen. Det er en fabrik af ListIterator-grænsefladen. Gennem ListIterator kan vi iterere listen frem og tilbage. Implementeringsklasserne for List-grænsefladen er ArrayList, LinkedList, Stack og Vector. ArrayList og LinkedList er meget udbredt i Java-programmering. Vector-klassen er forældet siden Java 5.
List og ArrayList i Java Collection Framework
Erklæring af Java List Interface
public interface List extends Collection ;>
Lad os komme nærmere ind på at skabe objekter eller forekomster i en listeklasse. Siden Liste er en interface , kan der ikke oprettes objekter af typelisten. Vi har altid brug for en klasse, der implementerer dette Liste for at skabe et objekt. Og også efter introduktionen af Generiske lægemidler i Java 1.5 er det muligt at begrænse den type objekt, der kan gemmes i listen. Ligesom flere andre brugerdefinerede 'grænseflader' implementeret af brugerdefinerede 'klasser', Liste er en 'grænseflade', implementeret af ArrayList klasse, foruddefineret i java.util pakke.
Syntaks af Java List
Denne type sikkerhedsliste kan defineres som:
List list = new ArrayList ();>
Bemærk: Obj er typen af objektet, der skal gemmes i List
Eksempel på Java List
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);> >}> }> |
>
>Produktion
[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>
Lad os nu udføre forskellige operationer ved hjælp af List Interface for at få en bedre forståelse af det samme. Vi vil diskutere følgende operationer nedenfor og senere om at implementere dem via rene Java-koder.
Operationer i en Java List Interface
Da List er en grænseflade, kan den kun bruges med en klasse, der implementerer denne grænseflade. Lad os nu se, hvordan du udfører et par ofte brugte operationer på listen.
- Operation 1: Tilføjelse af elementer til List klasse ved hjælp af add() metode
- Operation 2: Opdatering af elementer i List klasse ved hjælp af set() metode
- Operation 3: Søgning efter elementer ved hjælp af indexOf(), lastIndexOf metoder
- Operation 4: Fjernelse af elementer ved hjælp af remove() metoden
- Operation 5: Adgang til elementer i List-klassen ved hjælp af get()-metoden
- Operation 6: Kontrollerer om et element er til stede i List-klassen ved hjælp af contains()-metoden
Lad os nu diskutere operationerne individuelt og implementere det samme i koden for at få et bedre greb om det.
1. Tilføjelse af elementer til List klasse vha add() metode
For at tilføje et element til listen, kan vi bruge tilføje() metode. Denne metode er overbelastet til at udføre flere operationer baseret på forskellige parametre.
Parametre: Det kræver 2 parametre, nemlig:
- tilføje(Objekt): Denne metode bruges til at tilføje et element i slutningen af listen.
- add(int index, Object): Denne metode bruges til at tilføje et element til et specifikt indeks i listen
Eksempel:
Java
hvordan finder jeg ud af størrelsen på min skærm
// 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);> >}> }> |
>
>Produktion
[Geeks, For, Geeks]>
2. Opdatering af elementer
Efter tilføjelse af elementerne, hvis vi ønsker at ændre elementet, kan det gøres ved hjælp af sæt() metode. Da List er indekseret, refereres det element, som vi ønsker at ændre, af elementets indeks. Derfor tager denne metode et indeks og det opdaterede element, som skal indsættes i det indeks.
Eksempel:
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);> >}> }> |
>
>Produktion
Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>
3. Søger efter elementer
At søge efter elementer i List-grænsefladen er en almindelig operation i Java-programmering. Listegrænsefladen giver flere metoder til at søge efter elementer, såsom indeks af() , lastIndexOf() metoder.
indexOf()-metoden returnerer indekset for den første forekomst af et specificeret element på listen, mens lastIndexOf()-metoden returnerer indekset for den sidste forekomst af et specificeret element.
Parametre:
- indexOf(element): Returnerer indekset for den første forekomst af det angivne element på listen, eller -1, hvis elementet ikke findes
- lastIndexOf(element): Returnerer indekset for den sidste forekomst af det angivne element på listen, eller -1, hvis elementet ikke findes
Eksempel:
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);> >}> }> |
>
>Produktion
The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>
4. Fjernelse af elementer
For at fjerne et element fra en liste, kan vi bruge fjerne() metode. Denne metode er overbelastet til at udføre flere operationer baseret på forskellige parametre. De er:
Parametre:
- fjern (objekt): Denne metode bruges til blot at fjerne et objekt fra listen. Hvis der er flere sådanne objekter, fjernes den første forekomst af objektet.
- remove(int index): Da en liste er indekseret, tager denne metode en heltalsværdi, som blot fjerner det element, der er til stede ved det specifikke indeks på listen. Efter fjernelse af elementet flyttes alle elementer til venstre for at udfylde rummet, og objekternes indekser opdateres.
Eksempel:
Java
25 af 100
// 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);> >}> }> |
>
>Produktion
Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>
5. Adgang til elementer
For at få adgang til et element på listen kan vi bruge få() metode, som returnerer elementet ved det angivne indeks
Parametre:
get(int index): Denne metode returnerer elementet ved det angivne indeks på listen.
Eksempel:
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);> >}> }> |
>
>Produktion
Geeks For Geeks [Geeks, For, Geeks]>
6. Kontrollerer om et element er til stede på listen
For at kontrollere, om et element er til stede på listen, kan vi bruge indeholder() metode. Denne metode returnerer sand, hvis det angivne element er til stede på listen, ellers returnerer den falsk.
Parametre:
contains(Object): Denne metode tager en enkelt parameter, objektet skal kontrolleres, hvis det er til stede på listen.
Eksempel:
Java
// 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);> >}> }> |
>
>Produktion
Is Geeks present in the list? true>
Kompleksiteten af List Interface i Java
| Operation | Tidskompleksitet | Rumkompleksitet |
|---|---|---|
| Tilføjelse af element i listegrænseflade | O(1) | O(1) |
| Fjern element fra listegrænseflade | PÅ) | PÅ) diskret matematik negation |
| Erstat element i listegrænseflade | PÅ) | PÅ) |
| Traversing List Interface | PÅ) | PÅ) |
Iteration over List Interface i Java
Indtil nu har vi en meget lille inputstørrelse, og vi udfører operationer manuelt for hver enhed. Lad os nu diskutere forskellige måder, hvorpå vi kan iterere over listen for at få dem til at fungere for et større prøvesæt.
Metoder: Der er flere måder at gentage gennem listen. De mest berømte måder er ved at bruge det grundlæggende for sløjfe i kombination med en get() metode for at få elementet på et bestemt indeks og avanceret for en løkke .
Eksempel:
flette sorter i java
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 + ' '); } }> |
>
>Produktion
Geeks For Geeks Geeks For Geeks>
Metoder til listegrænsefladen
Da hovedkonceptet bag de forskellige typer lister er det samme, indeholder listegrænsefladen følgende metoder:
| Metode | Beskrivelse |
|---|---|
| add(int indeks, element) | Denne metode bruges med Java List Interface til at tilføje et element til et bestemt indeks på listen. Når en enkelt parameter sendes, tilføjer den blot elementet i slutningen af listen. |
| addAll(int index, Collection collection) | Denne metode bruges med List Interface i Java til at tilføje alle elementerne i den givne samling til listen. Når en enkelt parameter sendes, tilføjer den alle elementerne i den givne samling i slutningen af listen. |
| størrelse() | Denne metode bruges med Java List Interface til at returnere størrelsen på listen. |
| klar() | Denne metode bruges til at fjerne alle elementer på listen. Referencen til den oprettede liste er dog stadig gemt. |
| fjern (int indeks) | Denne metode fjerner et element fra det angivne indeks. Det flytter efterfølgende elementer (hvis nogen) til venstre og reducerer deres indeks med 1. |
| fjerne (element) | Denne metode bruges med Java List Interface til at fjerne den første forekomst af det givne element på listen. |
| get (int indeks) | Denne metode returnerer elementer ved det angivne indeks. |
| sæt(int indeks, element) | Denne metode erstatter elementer ved et givet indeks med det nye element. Denne funktion returnerer det element, som lige blev erstattet af et nyt element. |
| indeksOf(element) | Denne metode returnerer den første forekomst af det givne element eller -1 hvis elementet ikke er til stede på listen. |
| lastIndexOf(element) | Denne metode returnerer den sidste forekomst af det givne element eller -1 hvis elementet ikke er til stede på listen. |
| er lig med (element) | Denne metode bruges med Java List Interface til at sammenligne ligheden af det givne element med elementerne på listen. |
| hashCode() | Denne metode bruges med List Interface i Java til at returnere hashkodeværdien for den givne liste. |
| er tom() | Denne metode bruges med Java List Interface til at kontrollere, om listen er tom eller ej. Det returnerer sandt, hvis listen er tom, ellers falsk. |
| indeholder (element) | Denne metode bruges med List Interface i Java for at kontrollere, om listen indeholder det givne element eller ej. Det returnerer sandt, hvis listen indeholder elementet. |
| indeholder Alle (Samling samling) | Denne metode bruges med Java List Interface til at kontrollere, om listen indeholder hele samlingen af elementer. |
| sorter (Komparator comp) | Denne metode bruges sammen med List Interface i Java til at sortere listens elementer ud fra det givne komparator . |
Java List vs Set
Både List-grænsefladen og Set-grænsefladen arver Collection-grænsefladen. Der er dog nogle forskelle mellem dem.
| Liste | Sæt |
|---|---|
| Listen er en ordnet sekvens. | Sættet er en uordnet sekvens. |
| Liste tillader duplikerede elementer | Sæt tillader ikke duplikerede elementer. |
| Elementer efter deres placering kan tilgås. | Positionsadgang til elementer er ikke tilladt. |
| Flere nul-elementer kan gemmes. | Null-elementet kan kun lagre én gang. |
| Listeimplementeringer er ArrayList, LinkedList, Vector, Stack | Set implementeringer er HashSet, LinkedHashSet. |
Klasser Association med en Java List Interface
Lad os nu diskutere de klasser, der implementerer listegrænsefladen, som først refererer til den billedlige repræsentation nedenfor for at få en bedre forståelse af listegrænsefladen. Det er som følger:
Abstrakt liste , CopyOnWriteArrayList , og Abstrakt sekventiel liste er de klasser, der implementerer List-grænsefladen. En separat funktionalitet er implementeret i hver af de nævnte klasser. De er som følger:
- Abstrakt liste: Denne klasse bruges til at implementere en ikke-modificerbar liste, for hvilken man kun behøver at udvide denne AbstractList-klasse og kun implementere få() og størrelse() metoder.
- CopyOnWriteArrayList: Denne klasse implementerer listegrænsefladen. Det er en forbedret version af ArrayList hvor alle ændringerne (tilføj, sæt, fjern osv.) implementeres ved at lave en ny kopi af listen.
- Abstrakt sekventiel liste: Denne klasse implementerer Samling grænseflade og klassen AbstractCollection. Denne klasse bruges til at implementere en ikke-modificerbar liste, for hvilken man kun behøver at udvide denne AbstractList-klasse og kun implementere få() og størrelse() metoder.
Vi vil fortsætte på denne måde.
- ArrayList
- Vektor
- Stak
- LinkedList
Lad os diskutere dem sekventielt og implementere det samme for at finde ud af, hvordan klasserne fungerer med List-grænsefladen.
1. ArrayList
En ArrayList klasse, som er implementeret i samlingsrammerne, giver os dynamiske arrays i Java. Det kan dog være langsommere end standard arrays, men det kan være nyttigt i programmer, hvor der er behov for masser af manipulation i arrayet. Lad os se, hvordan du opretter et listeobjekt ved hjælp af denne klasse.
Eksempel:
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) + ' '); } }> |
>
>Produktion
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
2. Vektor
Vector er en klasse, der er implementeret i samlingsrammen og implementerer en udbredelig række af objekter. Vector implementerer et dynamisk array, der betyder, at det kan vokse eller krympe efter behov. Ligesom et array indeholder det komponenter, der kan tilgås ved hjælp af et heltalsindeks. Vektorer falder grundlæggende i ældre klasser, men nu er det fuldt kompatibelt med samlinger. Lad os se, hvordan du opretter et listeobjekt ved hjælp af denne klasse.
Eksempel:
Java
svm
// 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) + ' '); } }> |
>
>Produktion
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
3. Stak
Stack er en klasse, der er implementeret i samlingsrammen og udvider vektorklassemodellerne og implementerer Eksempel:
Java
Eksempel: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) + ' '); } }> |
>
>Produktion
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
4. LinkedList
Eksempel:
Java
LinkedList er en klasse, der er implementeret i samlingsrammerne, som i sagens natur implementerer Eksempel:Java
Eksempel:Java
// 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) + ' '); } }> |
>
>Produktion
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>