La interfície de llista de Java proporciona una manera d'emmagatzemar la col·lecció ordenada. És una interfície infantil de Col · lecció . És una col·lecció ordenada d'objectes en què es poden emmagatzemar valors duplicats. Com que List conserva l'ordre d'inserció, permet l'accés posicional i la inserció d'elements.
Taula de contingut
- Interfície de llista en Java
- Declaració de la interfície de llista de Java
- Exemple de llista Java
- Operacions en una interfície de llista Java
- Complexitat de la interfície de llista a Java
- Iteració sobre la interfície de llista a Java
- Mètodes de la interfície de llista
- Java List vs Set
Interfície de llista en Java
La interfície de llista es troba al paquet java.util i hereta la interfície de col·lecció. És una fàbrica de la interfície ListIterator. Mitjançant el ListIterator, podem iterar la llista en direccions cap endavant i cap enrere. Les classes d'implementació de la interfície List són ArrayList, LinkedList, Stack i Vector. ArrayList i LinkedList s'utilitzen àmpliament en la programació Java. La classe Vector està obsoleta des de Java 5.
Llista i ArrayList a Java Collection Framework
Declaració de la interfície de llista de Java
public interface List extends Collection ;>
Anem a elaborar més sobre la creació d'objectes o instàncies en una classe List. Des que Llista és un interfície , no es poden crear objectes de la llista de tipus. Sempre necessitem una classe que implementi això Llista per crear un objecte. I també, després de la introducció de Genèrics a Java 1.5, és possible restringir el tipus d'objecte que es pot emmagatzemar a la llista. Igual que diverses altres 'interfícies' definides per l'usuari implementades per 'classes' definides per l'usuari, Llista és una 'interfície', implementada pel ArrayList classe, predefinida a java.util paquet.
Sintaxi de la llista Java
Aquest tipus de llista segura es pot definir com:
List list = new ArrayList ();>
Nota: Obj és el tipus d'objecte que s'ha d'emmagatzemar a List
Exemple de llista Java
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);> >}> }> |
>
>Sortida
[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>
Ara anem a realitzar diverses operacions utilitzant la interfície de llista per entendre-les millor. Parlarem de les operacions següents que s'enumeren a continuació i més endavant les implementarem mitjançant codis Java nets.
Operacions en una interfície de llista Java
Com que List és una interfície, només es pot utilitzar amb una classe que implementi aquesta interfície. Ara, anem a veure com realitzar algunes operacions d'ús freqüent a la llista.
- Operació 1: Afegint elements a la classe List mitjançant el mètode add().
- Operació 2: Actualització d'elements a la classe List mitjançant el mètode set().
- Operació 3: Cerca d'elements mitjançant els mètodes indexOf(), lastIndexOf
- Operació 4: Eliminació d'elements mitjançant el mètode remove().
- Operació 5: Accés als elements de la classe List mitjançant el mètode get().
- Operació 6: Comprovar si un element està present a la classe List mitjançant el mètode contains().
Ara parlem de les operacions individualment i implementem les mateixes al codi per agafar-ne millor.
1. Afegint elements a la classe List utilitzant mètode add().
Per afegir un element a la llista, podem utilitzar el afegir() mètode. Aquest mètode està sobrecarregat per realitzar múltiples operacions basades en diferents paràmetres.
Paràmetres: Pren 2 paràmetres, a saber:
- afegir (Objecte): Aquest mètode s'utilitza per afegir un element al final de la llista.
- afegir (índex int, objecte): Aquest mètode s'utilitza per afegir un element a un índex específic de la llista
Exemple:
Java
cadena java a booleà
// 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);> >}> }> |
>
>Sortida
[Geeks, For, Geeks]>
2. Elements d'actualització
Després d'afegir els elements, si volem canviar l'element, es pot fer amb el conjunt() mètode. Com que la llista està indexada, l'índex de l'element fa referència a l'element que volem canviar. Per tant, aquest mètode pren un índex i l'element actualitzat que cal inserir en aquest índex.
Exemple:
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);> >}> }> |
>
>Sortida
Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>
3. Recerca d'elements
La cerca d'elements a la interfície de llista és una operació habitual a la programació Java. La interfície de llista proporciona diversos mètodes per cercar elements, com ara índex de() , lastIndexOf() mètodes.
El mètode indexOf() retorna l'índex de la primera ocurrència d'un element especificat de la llista, mentre que el mètode lastIndexOf() retorna l'índex de la darrera ocurrència d'un element especificat.
Paràmetres:
- indexOf(element): Retorna l'índex de la primera ocurrència de l'element especificat a la llista, o -1 si no es troba l'element
- lastIndexOf(element): Retorna l'índex de l'última ocurrència de l'element especificat a la llista, o -1 si no es troba l'element
Exemple:
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);> >}> }> |
>
>Sortida
The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>
4. Eliminació d'elements
Per eliminar un element d'una llista, podem utilitzar el eliminar () mètode. Aquest mètode està sobrecarregat per realitzar múltiples operacions basades en diferents paràmetres. Ells són:
Paràmetres:
- eliminar (Objecte): Aquest mètode s'utilitza per eliminar simplement un objecte de la llista. Si hi ha diversos objectes d'aquest tipus, s'elimina la primera ocurrència de l'objecte.
- eliminar (índex int): Com que una llista està indexada, aquest mètode pren un valor enter que simplement elimina l'element present en aquest índex específic de la llista. Després d'eliminar l'element, tots els elements es mouen cap a l'esquerra per omplir l'espai i s'actualitzen els índexs dels objectes.
Exemple:
Java
declaració de cas verilog
// 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);> >}> }> |
>
>Sortida
Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>
5. Elements d'accés
Per accedir a un element de la llista, podem utilitzar el aconseguir() mètode, que retorna l'element a l'índex especificat
Paràmetres:
get(índex int): aquest mètode retorna l'element a l'índex especificat a la llista.
Exemple:
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);> >}> }> |
>
>Sortida
Geeks For Geeks [Geeks, For, Geeks]>
6. Comprovar si hi ha un element a la llista
Per comprovar si hi ha un element a la llista, podem utilitzar el conté () mètode. Aquest mètode retorna true si l'element especificat està present a la llista, en cas contrari, retorna false.
Paràmetres:
conté(Objecte): aquest mètode pren un únic paràmetre, l'objecte que cal comprovar si està present a la llista.
Exemple:
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);> >}> }> |
>
>Sortida
Is Geeks present in the list? true>
Complexitat de la interfície de llista a Java
| Funcionament | Complexitat temporal | Complexitat espacial |
|---|---|---|
| Afegeix un element a la interfície de llista | O(1) classe abstracta en java | O(1) |
| Elimina l'element de la interfície de llista | O(N) | O(N) |
| Substitueix l'element a la interfície de llista | O(N) | O(N) |
| Interfície de llista de recorregut | O(N) prova de capturar el bloc java | O(N) |
Iteració sobre la interfície de llista a Java
Fins ara tenim una mida d'entrada molt petita i estem fent operacions manualment per a cada entitat. Ara anem a discutir diverses maneres en què podem recórrer la llista per fer-los funcionar per a un conjunt de mostres més gran.
Mètodes: Hi ha diverses maneres de recórrer la llista. Les maneres més famoses són utilitzant el bàsic per bucle en combinació amb a mètode get(). per obtenir l'element en un índex específic i el avançat per un bucle .
Exemple:
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 + ' '); } }> |
>
>Sortida
Geeks For Geeks Geeks For Geeks>
Mètodes de la interfície de llista
Com que el concepte principal dels diferents tipus de llistes és el mateix, la interfície de llista conté els mètodes següents:
| Mètode | Descripció |
|---|---|
| afegir (índex int, element) | Aquest mètode s'utilitza amb la interfície de llista de Java per afegir un element a un índex concret de la llista. Quan es passa un únic paràmetre, simplement afegeix l'element al final de la llista. |
| addAll(índex int, col·lecció de col·lecció) | Aquest mètode s'utilitza amb la interfície de llista a Java per afegir tots els elements de la col·lecció donada a la llista. Quan es passa un únic paràmetre, afegeix tots els elements de la col·lecció donada al final de la llista. |
| mida () | Aquest mètode s'utilitza amb Java List Interface per retornar la mida de la llista. |
| clar () | Aquest mètode s'utilitza per eliminar tots els elements de la llista. Tanmateix, la referència de la llista creada encara està emmagatzemada. |
| eliminar (índex int) | Aquest mètode elimina un element de l'índex especificat. Desplaça els elements posteriors (si n'hi ha) cap a l'esquerra i disminueix els seus índexs en 1. |
| eliminar (element) | Aquest mètode s'utilitza amb Java List Interface per eliminar la primera ocurrència de l'element donat a la llista. |
| obtenir (índex int) | Aquest mètode retorna elements a l'índex especificat. |
| set(índex int, element) | Aquest mètode substitueix els elements d'un índex determinat pel nou element. Aquesta funció retorna l'element que s'acaba de substituir per un nou element. |
| indexOf(element) | Aquest mètode retorna la primera ocurrència de l'element donat o -1 si l'element no està present a la llista. |
| lastIndexOf(element) | Aquest mètode retorna l'última ocurrència de l'element donat o -1 si l'element no està present a la llista. |
| és igual (element) | Aquest mètode s'utilitza amb Java List Interface per comparar la igualtat de l'element donat amb els elements de la llista. |
| hashCode() | Aquest mètode s'utilitza amb la interfície de llista a Java per retornar el valor de codi hash de la llista donada. |
| està buit() | Aquest mètode s'utilitza amb la interfície de llista de Java per comprovar si la llista està buida o no. Retorna true si la llista està buida, en cas contrari, fals. |
| conté (element) | Aquest mètode s'utilitza amb la interfície de llista a Java per comprovar si la llista conté l'element donat o no. Retorna true si la llista conté l'element. |
| containsAll (col·lecció de col·lecció) | Aquest mètode s'utilitza amb Java List Interface per comprovar si la llista conté tota la col·lecció d'elements. |
| ordenar (comparador de comparació) | Aquest mètode s'utilitza amb la interfície de llista a Java per ordenar els elements de la llista en funció del donat comparador . |
Java List vs Set
Tant la interfície Llista com la interfície Set hereten la interfície Col·lecció. Tanmateix, hi ha algunes diferències entre ells.
| Llista | Conjunt |
|---|---|
| La llista és una seqüència ordenada. | El conjunt és una seqüència no ordenada. |
| La llista permet duplicar elements | El conjunt no permet elements duplicats. |
| Es pot accedir als elements per la seva posició. | No està permès l'accés de posició als elements. |
| Es poden emmagatzemar diversos elements nuls. | L'element nul només es pot emmagatzemar una vegada. |
| Les implementacions de llista són ArrayList, LinkedList, Vector, Stack | Les implementacions del conjunt són HashSet, LinkedHashSet. |
Associació de classes amb una interfície de llista Java
Ara parlem de les classes que implementen la interfície de llista per a les quals primer es refereix a la representació pictòrica a continuació per entendre millor la interfície de llista. És el següent:
Llista abstracta , CopyOnWriteArrayList , i la AbstractSequentialList són les classes que implementen la interfície List. Una funcionalitat independent s'implementa en cadascuna de les classes esmentades. Són els següents:
- Llista abstracta: Aquesta classe s'utilitza per implementar una llista no modificable, per a la qual només cal ampliar aquesta classe AbstractList i implementar només la aconseguir() i la mida () mètodes.
- CopyOnWriteArrayList: Aquesta classe implementa la interfície de llista. És una versió millorada de ArrayList en què totes les modificacions (afegir, establir, eliminar, etc.) s'implementen fent una còpia nova de la llista.
- ResumSequentialList: Aquesta classe implementa el Interfície de col·lecció i la classe AbstractCollection. Aquesta classe s'utilitza per implementar una llista no modificable, per a la qual només cal ampliar aquesta classe AbstractList i implementar només la aconseguir() i la mida () mètodes.
Procedirem d'aquesta manera.
- ArrayList
- Vector
- Pila
- LinkedList
Parlem-ne seqüencialment i implementem el mateix per esbrinar el funcionament de les classes amb la interfície List.
1. ArrayList
Una ArrayList La classe que s'implementa al marc de col·lecció ens proporciona matrius dinàmiques en Java. Tanmateix, pot ser més lent que les matrius estàndard, però pot ser útil en programes on es necessita molta manipulació a la matriu. Vegem com crear un objecte de llista amb aquesta classe.
Exemple:
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) + ' '); } }> |
>
>Sortida
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
2. Vector
Vector és una classe que s'implementa al marc de col·lecció que implementa una matriu d'objectes que es pot augmentar. Vector implementa una matriu dinàmica que significa que pot créixer o reduir-se segons sigui necessari. Com una matriu, conté components als quals es pot accedir mitjançant un índex sencer. Els vectors bàsicament cauen en classes heretades, però ara és totalment compatible amb les col·leccions. Vegem com crear un objecte de llista amb aquesta classe.
Exemple:
Java
com recuperar aplicacions ocultes
// 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) + ' '); } }> |
>
>Sortida
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
3. Apilar
Stack és una classe que s'implementa al marc de la col·lecció i amplia els models de classes vectorials i implementa el Exemple:
Java
Exemple: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) + ' '); } }> |
>
>Sortida
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
4. LinkedList
Exemple:
Java
LinkedList és una classe que s'implementa en el marc de col·lecció que implementa de manera inherent el Exemple:Java
Exemple: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) + ' '); } }> |
>
>Sortida
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>