Listgränssnittet i Java tillhandahåller ett sätt att lagra den beställda samlingen. Det är ett barngränssnitt av Samling . Det är en ordnad samling objekt där dubbla värden kan lagras. Eftersom List bevarar insättningsordningen tillåter den positionell åtkomst och infogning av element.
Innehållsförteckning
- Listgränssnitt i Java
- Deklaration av Java List Interface
- Exempel på Java List
- Operationer i ett Java List Interface
- Komplexiteten av listgränssnitt i Java
- Itererar över listgränssnitt i Java
- Metoder för listgränssnittet
- Java List vs Set
Listgränssnitt i Java
Listgränssnittet finns i paketet java.util och ärver samlingsgränssnittet. Det är en fabrik av ListIterator-gränssnittet. Genom ListIterator kan vi iterera listan i riktningar framåt och bakåt. Implementeringsklasserna för List-gränssnittet är ArrayList, LinkedList, Stack och Vector. ArrayList och LinkedList används ofta i Java-programmering. Klassen Vector är utfasad sedan Java 5.
Lista och ArrayList i Java Collection Framework
Deklaration av Java List Interface
public interface List extends Collection ;>
Låt oss utveckla objekt eller instanser i en List-klass. Eftersom Lista är en gränssnitt , objekt kan inte skapas av typlistan. Vi behöver alltid en klass som implementerar detta Lista för att skapa ett objekt. Och även efter införandet av Generika i Java 1.5 är det möjligt att begränsa typen av objekt som kan lagras i listan. Precis som flera andra användardefinierade 'gränssnitt' implementerade av användardefinierade 'klasser', Lista är ett 'gränssnitt', implementerat av ArrayList klass, fördefinierad i java.util paket.
Syntax för Java List
Denna typ av säkerhetslistor kan definieras som:
List list = new ArrayList ();>
Notera: Obj är typen av objekt som ska lagras i List
Exempel 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]>
Låt oss nu utföra olika operationer med List Interface för att få en bättre förståelse av detsamma. Vi kommer att diskutera följande operationer som listas nedan och senare om att implementera dem via rena Java-koder.
Operationer i ett Java List Interface
Eftersom List är ett gränssnitt kan det endast användas med en klass som implementerar detta gränssnitt. Låt oss nu se hur man utför några ofta använda operationer på listan.
- Operation 1: Lägga till element till klassen List med metoden add().
- Operation 2: Uppdatering av element i klassen List med metoden set().
- Operation 3: Söker efter element med metoderna indexOf(), lastIndexOf
- Operation 4: Ta bort element med metoden remove().
- Operation 5: Åtkomst till element i klassen List med metoden get().
- Operation 6: Kontrollera om ett element finns i klassen List med metoden contains().
Låt oss nu diskutera operationerna individuellt och implementera detsamma i koden för att få ett bättre grepp om den.
1. Lägga till element i List-klassen med hjälp av add() metod
För att lägga till ett element i listan kan vi använda Lägg till() metod. Denna metod är överbelastad för att utföra flera operationer baserat på olika parametrar.
Parametrar: Det krävs 2 parametrar, nämligen:
- add(Objekt): Denna metod används för att lägga till ett element i slutet av listan.
- add(int index, Object): Denna metod används för att lägga till ett element i ett specifikt index i listan
Exempel:
Java
java list nod
// 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. Uppdaterar element
Efter att ha lagt till elementen, om vi vill ändra elementet, kan det göras med hjälp av uppsättning() metod. Eftersom List är indexerad, refereras det element som vi vill ändra till av elementets index. Därför tar denna metod ett index och det uppdaterade elementet som måste infogas vid det indexet.
Exempel:
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öker efter element
Att söka efter element i List-gränssnittet är en vanlig operation i Java-programmering. Listgränssnittet tillhandahåller flera metoder för att söka efter element, till exempel index för() , lastIndexOf() metoder.
Metoden indexOf() returnerar indexet för den första förekomsten av ett angivet element i listan, medan metoden lastIndexOf() returnerar indexet för den senaste förekomsten av ett angivet element.
Parametrar:
- indexOf(element): Returnerar indexet för den första förekomsten av det angivna elementet i listan, eller -1 om elementet inte hittas
- lastIndexOf(element): Returnerar indexet för den senaste förekomsten av det angivna elementet i listan, eller -1 om elementet inte hittas
Exempel:
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. Ta bort element
För att ta bort ett element från en lista kan vi använda avlägsna() metod. Denna metod är överbelastad för att utföra flera operationer baserat på olika parametrar. Dom är:
Parametrar:
- remove(Object): Denna metod används för att helt enkelt ta bort ett objekt från listan. Om det finns flera sådana objekt tas den första förekomsten av objektet bort.
- remove(int index): Eftersom en lista är indexerad tar denna metod ett heltalsvärde som helt enkelt tar bort elementet som finns i det specifika indexet i listan. Efter att ha tagit bort elementet flyttas alla element till vänster för att fylla utrymmet och objektens index uppdateras.
Exempel:
Java
ram tkinter
// 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. Åtkomst till element
För att komma åt ett element i listan kan vi använda skaffa sig() metod, som returnerar elementet vid det angivna indexet
Parametrar:
get(int index): Denna metod returnerar elementet vid det angivna indexet i listan.
Exempel:
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. Kontrollera om ett element finns i listan
För att kontrollera om ett element finns i listan kan vi använda innehåller() metod. Denna metod returnerar true om det angivna elementet finns i listan, annars returnerar den false.
Parametrar:
contains(Object): Denna metod tar en enda parameter, objektet som ska kontrolleras om det finns i listan.
Exempel:
Java
fibonacci kod 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>
Komplexiteten av listgränssnitt i Java
| Drift | Tidskomplexitet | Rymdkomplexitet |
|---|---|---|
| Lägger till element i listgränssnittet | O(1) | O(1) |
| Ta bort element från listgränssnittet | PÅ) | PÅ) |
| Ersätt element i listgränssnitt | PÅ) | PÅ) |
| Övergångslistgränssnitt | PÅ) | PÅ) |
Itererar över listgränssnitt i Java
Hittills har vi en mycket liten indatastorlek och vi gör operationer manuellt för varje enhet. Låt oss nu diskutera olika sätt på vilka vi kan iterera över listan för att få dem att fungera för en större provuppsättning.
Metoder: Det finns flera sätt att iterera genom listan. De mest kända sätten är att använda de grundläggande för slinga i kombination med en get() metoden för att få elementet vid ett specifikt index och avancerat för en slinga .
Exempel:
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 för listgränssnittet
Eftersom huvudkonceptet bakom de olika typerna av listor är detsamma, innehåller listgränssnittet följande metoder:
| Metod | Beskrivning |
|---|---|
| add(int index, element) | Denna metod används med Java List Interface för att lägga till ett element i ett visst index i listan. När en enskild parameter skickas lägger den helt enkelt till elementet i slutet av listan. |
| addAll(int index, Collection collection) | Denna metod används med List Interface i Java för att lägga till alla element i den givna samlingen till listan. När en enskild parameter skickas, lägger den till alla element i den givna samlingen i slutet av listan. |
| storlek() | Denna metod används med Java List Interface för att returnera storleken på listan. |
| klar() | Denna metod används för att ta bort alla element i listan. Referensen till den skapade listan lagras dock fortfarande. |
| remove(int index) | Denna metod tar bort ett element från det angivna indexet. Den flyttar efterföljande element (om några) till vänster och minskar deras index med 1. |
| remove(element) | Denna metod används med Java List Interface för att ta bort den första förekomsten av det givna elementet i listan. |
| get(int index) | Denna metod returnerar element vid det angivna indexet. |
| set(int index, element) | Denna metod ersätter element vid ett givet index med det nya elementet. Denna funktion returnerar elementet som just ersattes av ett nytt element. |
| indexOf(element) | Denna metod returnerar den första förekomsten av det givna elementet eller -1 om elementet inte finns i listan. |
| lastIndexOf(element) | Denna metod returnerar den senaste förekomsten av det givna elementet eller -1 om elementet inte finns i listan. |
| lika med (element) | Denna metod används med Java List Interface för att jämföra det givna elementets likhet med elementen i listan. |
| hash-kod() | Denna metod används med List Interface i Java för att returnera hashkodvärdet för den givna listan. |
| är tom() | Denna metod används med Java List Interface för att kontrollera om listan är tom eller inte. Det returnerar sant om listan är tom, annars falskt. |
| innehåller(element) | Denna metod används med List Interface i Java för att kontrollera om listan innehåller det givna elementet eller inte. Det returnerar sant om listan innehåller elementet. |
| containsAll(samlingssamling) | Denna metod används med Java List Interface för att kontrollera om listan innehåller all samling av element. |
| sort(Comparator comp) | Denna metod används med List Interface i Java för att sortera elementen i listan utifrån det givna komparator . |
Java List vs Set
Både List-gränssnittet och Set-gränssnittet ärver Collection-gränssnittet. Det finns dock vissa skillnader mellan dem.
| Lista | Uppsättning |
|---|---|
| Listan är en ordnad sekvens. | Setet är en oordnad sekvens. |
| Lista tillåter dubbletter av element | Uppsättningen tillåter inte dubbletter av element. |
| Element genom deras position kan nås. | Positionsåtkomst till element är inte tillåten. |
| Flera nullelement kan lagras. | Null-elementet kan bara lagras en gång. |
| Listimplementationer är ArrayList, LinkedList, Vector, Stack | Uppsättningsimplementationer är HashSet, LinkedHashSet. |
Klasser Association med ett Java List Interface
Låt oss nu diskutera de klasser som implementerar listgränssnittet för vilka först hänvisar till bildrepresentationen nedan för att få en bättre förståelse av listgränssnittet. Det är som följer:
Abstrakt lista , CopyOnWriteArrayList , och den AbstractSequential List är klasserna som implementerar List-gränssnittet. En separat funktionalitet är implementerad i var och en av de nämnda klasserna. De är följande:
- Abstrakt lista: Denna klass används för att implementera en oförändrbar lista, för vilken man bara behöver utöka denna AbstractList Class och implementera endast skaffa sig() och den storlek() metoder.
- CopyOnWriteArrayList: Denna klass implementerar listgränssnittet. Det är en förbättrad version av ArrayList där alla ändringar (lägg till, ställ in, ta bort, etc.) implementeras genom att göra en ny kopia av listan.
- AbstractSequential List: Denna klass implementerar Samlingsgränssnitt och klassen AbstractCollection. Denna klass används för att implementera en oförändrbar lista, för vilken man bara behöver utöka denna AbstractList Class och implementera endast skaffa sig() och den storlek() metoder.
Vi kommer att gå vidare på detta sätt.
- ArrayList
- Vektor
- Stack
- Länkad lista
Låt oss diskutera dem sekventiellt och implementera detsamma för att ta reda på hur klasserna fungerar med List-gränssnittet.
1. ArrayList
En ArrayList klass som är implementerad i samlingsramverket ger oss dynamiska arrayer i Java. Det kan dock vara långsammare än vanliga arrayer men kan vara till hjälp i program där mycket manipulation i arrayen behövs. Låt oss se hur man skapar ett listobjekt med den här klassen.
Exempel:
java hej-program
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 är en klass som är implementerad i samlingsramverket implementerar en odlingsbar mängd objekt. Vector implementerar en dynamisk array som innebär att den kan växa eller krympa efter behov. Liksom en array innehåller den komponenter som kan nås med ett heltalsindex. Vektorer faller i princip i äldre klasser men nu är det helt kompatibelt med samlingar. Låt oss se hur man skapar ett listobjekt med den här klassen.
Exempel:
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) + ' '); } }> |
>
>Produktion
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
3. Stapla
Stack är en klass som är implementerad i samlingsramverket och utökar vektorklassmodellerna och implementerar Exempel:
Java
Exempel: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. Länkad lista
Exempel:
Java
LinkedList är en klass som är implementerad i samlingsramverket som i sig implementerar Exempel:Java
Exempel:Java
uppföljande datatyper
// 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>