L'interfaccia List in Java fornisce un modo per archiviare la raccolta ordinata. È un'interfaccia figlia di Collezione . È una raccolta ordinata di oggetti in cui è possibile archiviare valori duplicati. Poiché List preserva l'ordine di inserimento, consente l'accesso posizionale e l'inserimento di elementi.
Tabella dei contenuti
- Elenco interfaccia in Java
- Dichiarazione dell'interfaccia dell'elenco Java
- Esempio di elenco Java
- Operazioni in un'interfaccia di elenco Java
- Complessità dell'interfaccia dell'elenco in Java
- Iterazione sull'interfaccia List in Java
- Metodi dell'interfaccia Elenco
- Elenco Java e set
Elenco interfaccia in Java
L'interfaccia List si trova nel pacchetto java.util ed eredita l'interfaccia Collection. È una factory dell'interfaccia ListIterator. Attraverso ListIterator, possiamo scorrere l'elenco in avanti e all'indietro. Le classi di implementazione dell'interfaccia List sono ArrayList, LinkedList, Stack e Vector. ArrayList e LinkedList sono ampiamente utilizzati nella programmazione Java. La classe Vector è deprecata a partire da Java 5.
List e ArrayList nel Java Collection Framework
Dichiarazione dell'interfaccia dell'elenco Java
public interface List extends Collection ;>
Esaminiamo ora la creazione di oggetti o istanze in una classe List. Da Elenco è un interfaccia , non è possibile creare oggetti dall'elenco dei tipi. Abbiamo sempre bisogno di una classe che lo implementi Elenco per creare un oggetto. E inoltre, dopo l'introduzione di Generici in Java 1.5 è possibile limitare il tipo di oggetto che può essere memorizzato nell'Elenco. Proprio come molte altre “interfacce” definite dall’utente implementate da “classi” definite dall’utente, Elenco è un''interfaccia', implementata da Lista di array classe, predefinita in java.util pacchetto.
Sintassi dell'elenco Java
Questo tipo di elenco attendibile può essere definito come:
List list = new ArrayList ();>
Nota: Obj è il tipo dell'oggetto da archiviare in List
Esempio di elenco Java
Giava
// 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);> >}> }> |
>
>Produzione
[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>
Ora eseguiamo varie operazioni utilizzando l'interfaccia List per avere una migliore comprensione della stessa. Discuteremo le seguenti operazioni elencate di seguito e successivamente le implementeremo tramite codici Java puliti.
Operazioni in un'interfaccia di elenco Java
Poiché List è un'interfaccia, può essere utilizzata solo con una classe che implementa questa interfaccia. Ora vediamo come eseguire alcune operazioni utilizzate di frequente sull'Elenco.
- Operazione 1: Aggiunta di elementi alla classe List utilizzando il metodo add()
- Operazione 2: Aggiornamento degli elementi nella classe List utilizzando il metodo set()
- Operazione 3: Ricerca di elementi utilizzando i metodi indexOf() e lastIndexOf
- Operazione 4: Rimozione di elementi utilizzando il metodo Remove()
- Operazione 5: Accesso agli elementi nella classe List utilizzando il metodo get()
- Operazione 6: Verifica se un elemento è presente nella classe List utilizzando il metodo contiene()
Ora discutiamo le operazioni individualmente e implementiamo le stesse nel codice per comprenderle meglio.
1. Aggiunta di elementi alla classe List utilizzando metodo add()
Per aggiungere un elemento alla lista, possiamo usare il aggiungere() metodo. Questo metodo è sovraccaricato per eseguire più operazioni in base a parametri diversi.
parametri: Ci vogliono 2 parametri e cioè:
- aggiungi(Oggetto): Questo metodo viene utilizzato per aggiungere un elemento alla fine della Lista.
- add(int indice, Oggetto): Questo metodo viene utilizzato per aggiungere un elemento a un indice specifico nell'elenco
Esempio:
Giava
costruttore di corde
// 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);> >}> }> |
>
>Produzione
[Geeks, For, Geeks]>
2. Aggiornamento degli elementi
Dopo aver aggiunto gli elementi, se desideriamo modificare l'elemento, possiamo farlo utilizzando il file impostato() metodo. Poiché List è indicizzato, l'elemento che desideriamo modificare viene referenziato dall'indice dell'elemento. Pertanto, questo metodo accetta un indice e l'elemento aggiornato che deve essere inserito in quell'indice.
Esempio:
Giava
// 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);> >}> }> |
>
>Produzione
Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>
3. Ricerca di elementi
La ricerca di elementi nell'interfaccia Elenco è un'operazione comune nella programmazione Java. L'interfaccia Elenco fornisce diversi metodi per cercare elementi, come ad esempio indice di() , ultimoIndiceOf() metodi.
Il metodo indexOf() restituisce l'indice della prima occorrenza di un elemento specificato nell'elenco, mentre il metodo lastIndexOf() restituisce l'indice dell'ultima occorrenza di un elemento specificato.
parametri:
- indiceDi(elemento): Restituisce l'indice della prima occorrenza dell'elemento specificato nell'elenco oppure -1 se l'elemento non viene trovato
- ultimoIndiceOf(elemento): Restituisce l'indice dell'ultima occorrenza dell'elemento specificato nell'elenco oppure -1 se l'elemento non viene trovato
Esempio:
Giava
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);> >}> }> |
>
>Produzione
The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>
4. Rimozione di elementi
Per rimuovere un elemento da una lista possiamo usare il comando rimuovere() metodo. Questo metodo è sovraccaricato per eseguire più operazioni in base a parametri diversi. Sono:
parametri:
- rimuovi(Oggetto): Questo metodo viene utilizzato per rimuovere semplicemente un oggetto dall'elenco. Se sono presenti più oggetti di questo tipo, viene rimossa la prima occorrenza dell'oggetto.
- rimuovi(int indice): Poiché una Lista è indicizzata, questo metodo assume un valore intero che rimuove semplicemente l'elemento presente in quello specifico indice nella Lista. Dopo aver rimosso l'elemento, tutti gli elementi vengono spostati a sinistra per riempire lo spazio e gli indici degli oggetti vengono aggiornati.
Esempio:
Giava
elenco delle freccette
// 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);> >}> }> |
>
>Produzione
Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>
5. Accesso agli elementi
Per accedere ad un elemento della lista possiamo usare il comando Ottenere() metodo, che restituisce l'elemento all'indice specificato
parametri:
get(int indice): questo metodo restituisce l'elemento all'indice specificato nell'elenco.
Esempio:
Giava
// 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);> >}> }> |
>
>Produzione
Geeks For Geeks [Geeks, For, Geeks]>
6. Verifica se un elemento è presente nella Lista
Per verificare se un elemento è presente nella lista possiamo utilizzare il file contiene() metodo. Questo metodo restituisce true se l'elemento specificato è presente nell'elenco, altrimenti restituisce false.
parametri:
contiene(Oggetto): questo metodo accetta un singolo parametro, l'oggetto da verificare se è presente nell'elenco.
Esempio:
test delle prestazioni
Giava
// 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);> >}> }> |
>
>Produzione
Is Geeks present in the list? true>
Complessità dell'interfaccia dell'elenco in Java
| Operazione | Complessità temporale | Complessità spaziale |
|---|---|---|
| Aggiunta di elementi nell'interfaccia dell'elenco | O(1) | O(1) |
| Rimuovi l'elemento dall'interfaccia dell'elenco | SU) | SU) |
| Sostituisci elemento nell'interfaccia elenco | SU) | SU) |
| Interfaccia dell'elenco di attraversamento | SU) | SU) |
Iterazione sull'interfaccia List in Java
Fino ad ora abbiamo una dimensione di input molto piccola e stiamo eseguendo operazioni manualmente per ogni entità. Parliamo ora dei vari modi in cui possiamo scorrere l'elenco per farli funzionare per un set di campioni più ampio.
Metodi: Esistono diversi modi per scorrere l'elenco. I modi più famosi sono utilizzando il basic per ciclo in combinazione con a metodo get() per ottenere l'elemento in un indice specifico e il avanzato per un ciclo .
Esempio:
Giava
// 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 + ' '); } }> |
>
>Produzione
Geeks For Geeks Geeks For Geeks>
Metodi dell'interfaccia Elenco
Poiché il concetto principale alla base dei diversi tipi di elenchi è lo stesso, l'interfaccia dell'elenco contiene i seguenti metodi:
| Metodo | Descrizione |
|---|---|
| add(int indice, elemento) | Questo metodo viene utilizzato con Java List Interface per aggiungere un elemento a un particolare indice nell'elenco. Quando viene passato un singolo parametro, aggiunge semplicemente l'elemento alla fine dell'elenco. |
| addAll(int indice, raccolta raccolta) | Questo metodo viene utilizzato con List Interface in Java per aggiungere tutti gli elementi nella raccolta data all'elenco. Quando viene passato un singolo parametro, aggiunge tutti gli elementi della raccolta data alla fine dell'elenco. |
| misurare() | Questo metodo viene utilizzato con Java List Interface per restituire la dimensione dell'elenco. |
| chiaro() | Questo metodo viene utilizzato per rimuovere tutti gli elementi nell'elenco. Tuttavia, il riferimento dell'elenco creato rimane comunque memorizzato. |
| rimuovi(indice int) | Questo metodo rimuove un elemento dall'indice specificato. Sposta gli elementi successivi (se presenti) a sinistra e diminuisce i loro indici di 1. |
| rimuovi (elemento) | Questo metodo viene utilizzato con Java List Interface per rimuovere la prima occorrenza dell'elemento specificato nell'elenco. |
| get(indice int) | Questo metodo restituisce gli elementi nell'indice specificato. |
| set(int indice, elemento) | Questo metodo sostituisce gli elementi in un dato indice con il nuovo elemento. Questa funzione restituisce l'elemento che è stato appena sostituito da un nuovo elemento. |
| indiceDi(elemento) | Questo metodo restituisce la prima occorrenza dell'elemento specificato o -1 se l'elemento non è presente nella lista. |
| ultimoIndiceOf(elemento) | Questo metodo restituisce l'ultima occorrenza dell'elemento specificato o -1 se l'elemento non è presente nella lista. |
| uguale(elemento) | Questo metodo viene utilizzato con Java List Interface per confrontare l'uguaglianza dell'elemento fornito con gli elementi dell'elenco. |
| codice hash() | Questo metodo viene utilizzato con List Interface in Java per restituire il valore hashcode dell'elenco fornito. |
| è vuoto() | Questo metodo viene utilizzato con Java List Interface per verificare se l'elenco è vuoto o meno. Restituisce vero se la lista è vuota, altrimenti falso. |
| contiene(elemento) | Questo metodo viene utilizzato con List Interface in Java per verificare se l'elenco contiene o meno l'elemento specificato. Restituisce vero se la lista contiene l'elemento. |
| contieneTutto(raccolta Collezione) | Questo metodo viene utilizzato con Java List Interface per verificare se l'elenco contiene tutta la raccolta di elementi. |
| sort(Comparatore comp) | Questo metodo viene utilizzato con List Interface in Java per ordinare gli elementi della lista in base a quanto indicato comparatore . |
Elenco Java e set
Sia l'interfaccia List che l'interfaccia Set ereditano l'interfaccia Collection. Tuttavia, esistono alcune differenze tra loro.
| Elenco | Impostato |
|---|---|
| La Lista è una sequenza ordinata. | Il Set è una sequenza non ordinata. |
| L'elenco consente elementi duplicati | Set non consente elementi duplicati. |
| È possibile accedere agli elementi in base alla loro posizione. | L'accesso alla posizione degli elementi non è consentito. |
| È possibile memorizzare più elementi nulli. | L'elemento null può essere memorizzato solo una volta. |
| Le implementazioni dell'elenco sono ArrayList, LinkedList, Vector, Stack | Le implementazioni dei set sono HashSet, LinkedHashSet. |
Associazione di classi con un'interfaccia di elenco Java
Parliamo ora delle classi che implementano l'interfaccia List per le quali facciamo prima riferimento alla rappresentazione pittorica seguente per comprendere meglio l'interfaccia List. È il seguente:
AbstractList , CopyOnWriteArrayList , e il AbstractSequentialList sono le classi che implementano l'interfaccia List. In ciascuna delle classi menzionate è implementata una funzionalità separata. Sono i seguenti:
matematica di Java
- Elenco astratto: Questa classe viene utilizzata per implementare un elenco immodificabile, per il quale è necessario estendere solo questa classe AbstractList e implementare solo il Ottenere() e il misurare() metodi.
- CopyOnWriteArrayList: Questa classe implementa l'interfaccia dell'elenco. È una versione migliorata di Lista di array in cui tutte le modifiche (aggiunta, impostazione, rimozione, ecc.) vengono implementate creando una nuova copia dell'elenco.
- Elencosequenzialeastratto: Questa classe implementa il Interfaccia di raccolta e la classe AbstractCollection. Questa classe viene utilizzata per implementare un elenco immodificabile, per il quale è necessario estendere solo questa classe AbstractList e implementare solo il Ottenere() e il misurare() metodi.
Procederemo in questo modo.
- Lista di array
- Vettore
- Pila
- Lista collegata
Discutiamoli in sequenza e implementiamo lo stesso per capire il funzionamento delle classi con l'interfaccia List.
1. Elenco array
Un ArrayList La classe implementata nel framework della raccolta ci fornisce array dinamici in Java. Tuttavia, potrebbe essere più lento degli array standard ma può essere utile nei programmi in cui è necessaria molta manipolazione nell'array. Vediamo come creare un oggetto lista utilizzando questa classe.
Esempio:
Giava
// 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) + ' '); } }> |
>
>Produzione
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
2. Vettore
Vector è una classe implementata nel framework della raccolta che implementa una serie di oggetti espandibili. Vector implementa un array dinamico, il che significa che può crescere o ridursi a seconda delle esigenze. Come un array, contiene componenti a cui è possibile accedere utilizzando un indice intero. I vettori fondamentalmente rientrano nelle classi legacy ma ora sono completamente compatibili con le raccolte. Vediamo come creare un oggetto lista utilizzando questa classe.
Esempio:
Giava
// 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) + ' '); } }> |
>
>Produzione
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
3. Impilare
Stack è una classe implementata nel framework della raccolta ed estende i modelli di classi vettoriali e implementa i file Esempio:
Giava
Esempio:Giava
// 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) + ' '); } }> |
>
>Produzione
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
4. Elenco collegato
Esempio:
chiave del periodo
Giava
LinkedList è una classe implementata nel framework della raccolta che implementa intrinsecamente il file Esempio:Giava
Esempio:Giava
// 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) + ' '); } }> |
>
>Produzione
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>