Interfața List din Java oferă o modalitate de a stoca colecția comandată. Este o interfață copil a Colectie . Este o colecție ordonată de obiecte în care pot fi stocate valori duplicate. Deoarece List păstrează ordinea de inserare, permite accesul pozițional și inserarea elementelor.
Cuprins
- List Interfață în Java
- Declarația Java List Interface
- Exemplu de listă Java
- Operații într-o interfață de listă Java
- Complexitatea interfeței Listă în Java
- Iterarea peste Interfața Listă în Java
- Metode ale interfeței Listă
- Lista Java vs Set
List Interfață în Java
Interfața Listă se găsește în pachetul java.util și moștenește interfața Collection. Este o fabrică a interfeței ListIterator. Prin ListIterator, putem repeta lista în direcții înainte și înapoi. Clasele de implementare ale interfeței List sunt ArrayList, LinkedList, Stack și Vector. ArrayList și LinkedList sunt utilizate pe scară largă în programarea Java. Clasa Vector este depreciată din Java 5.
Listă și ArrayList în Java Collection Framework
Declarația Java List Interface
public interface List extends Collection ;>
Să detaliem despre crearea de obiecte sau instanțe într-o clasă List. De cand Listă este o interfață , nu pot fi create obiecte din lista de tipuri. Avem întotdeauna nevoie de o clasă care implementează acest lucru Listă pentru a crea un obiect. Și, de asemenea, după introducerea generice în Java 1.5, este posibil să restricționați tipul de obiect care poate fi stocat în Listă. La fel ca alte câteva „interfețe” definite de utilizator implementate de „clase” definite de utilizator, Listă este o „interfață”, implementată de ArrayList clasa, predefinită în java.util pachet.
Sintaxa listei Java
Acest tip de listă sigură poate fi definită astfel:
List list = new ArrayList ();>
Notă: Obj este tipul de obiect care trebuie stocat în Listă
Exemplu de listă 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);> >}> }> |
>
>Ieșire
[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>
Acum haideți să efectuăm diferite operații folosind List Interface pentru a înțelege mai bine aceeași. Vom discuta despre următoarele operațiuni enumerate mai jos și mai târziu despre implementarea lor prin coduri Java curate.
Operații într-o interfață de listă Java
Deoarece List este o interfață, poate fi folosită numai cu o clasă care implementează această interfață. Acum, să vedem cum să efectuați câteva operațiuni frecvent utilizate pe Listă.
- Operațiunea 1: Adăugarea de elemente la clasa List folosind metoda add().
- Operațiunea 2: Actualizarea elementelor din clasa List folosind metoda set().
- Operațiunea 3: Căutarea elementelor folosind metodele indexOf(), lastIndexOf
- Operațiunea 4: Eliminarea elementelor folosind metoda remove().
- Operațiunea 5: Accesarea elementelor din clasa List folosind metoda get().
- Operațiunea 6: Verificarea dacă un element este prezent în clasa List folosind metoda contains().
Acum haideți să discutăm despre operațiuni în mod individual și să implementăm același lucru în cod pentru a înțelege mai bine.
1. Adăugarea de elemente la clasa List folosind metoda add().
Pentru a adăuga un element în listă, putem folosi adăuga() metodă. Această metodă este supraîncărcată pentru a efectua mai multe operații bazate pe diferiți parametri.
Parametri: Este nevoie de 2 parametri, și anume:
- adauga (Obiect): Această metodă este folosită pentru a adăuga un element la sfârșitul Listei.
- add(int index, Object): Această metodă este folosită pentru a adăuga un element la un index specific din Listă
Exemplu:
Java
zerouri numpy
// 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);> >}> }> |
>
>Ieșire
[Geeks, For, Geeks]>
2. Elemente de actualizare
După adăugarea elementelor, dacă dorim să schimbăm elementul, se poate face folosind funcția a stabilit() metodă. Deoarece Listă este indexată, elementul pe care dorim să-l schimbăm este referit de indexul elementului. Prin urmare, această metodă ia un index și elementul actualizat care trebuie inserat la acel index.
Exemplu:
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);> >}> }> |
>
>Ieșire
Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>
3. Căutarea elementelor
Căutarea elementelor în interfața Listă este o operație comună în programarea Java. Interfața List oferă mai multe metode de căutare a elementelor, cum ar fi Index de() , lastIndexOf() metode.
Metoda indexOf() returnează indexul primei apariții a unui element specificat din listă, în timp ce metoda lastIndexOf() returnează indexul ultimei apariții a unui element specificat.
Parametri:
- indexOf(element): Returnează indexul primei apariții a elementului specificat din listă sau -1 dacă elementul nu este găsit
- lastIndexOf(element): Returnează indexul ultimei apariții a elementului specificat din listă sau -1 dacă elementul nu este găsit
Exemplu:
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);> >}> }> |
>
>Ieșire
The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>
4. Îndepărtarea elementelor
Pentru a elimina un element dintr-o listă, putem folosi elimina() metodă. Această metodă este supraîncărcată pentru a efectua mai multe operații bazate pe diferiți parametri. Sunt:
Parametri:
- elimina (Obiect): Această metodă este folosită pentru a elimina pur și simplu un obiect din Listă. Dacă există mai multe astfel de obiecte, atunci prima apariție a obiectului este eliminată.
- elimina (index int): Deoarece o Listă este indexată, această metodă ia o valoare întreagă care pur și simplu elimină elementul prezent la acel index specific din Listă. După eliminarea elementului, toate elementele sunt mutate spre stânga pentru a umple spațiul și indicii obiectelor sunt actualizați.
Exemplu:
Java
exemplu de javascript
// 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);> >}> }> |
>
>Ieșire
Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>
5. Accesarea elementelor
Pentru a accesa un element din listă, putem folosi obține() metoda, care returnează elementul la indexul specificat
Parametri:
get(int index): Această metodă returnează elementul la indexul specificat în listă.
Exemplu:
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);> >}> }> |
>
>Ieșire
Geeks For Geeks [Geeks, For, Geeks]>
6. Verificarea dacă un element este prezent în Listă
Pentru a verifica dacă un element este prezent în listă, putem folosi conține() metodă. Această metodă returnează true dacă elementul specificat este prezent în listă, în caz contrar, returnează false.
Parametri:
nume de utilizator
conţine(Obiect): Această metodă ia un singur parametru, obiectul urmând să fie verificat dacă este prezent în listă.
Exemplu:
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);> >}> }> |
>
>Ieșire
Is Geeks present in the list? true>
Complexitatea interfeței Listă în Java
| Operațiune | Complexitatea timpului | Complexitatea spațială |
|---|---|---|
| Adăugarea unui element în interfața Listă | O(1) | O(1) |
| Eliminați elementul din interfața Listă | PE) | PE) |
| Înlocuiți elementul în interfața Listă | PE) | PE) |
| Interfața de parcurgere a listei | PE) | PE) |
Iterarea peste Interfața Listă în Java
Până acum avem o dimensiune de intrare foarte mică și facem operațiuni manual pentru fiecare entitate. Acum haideți să discutăm diferite moduri prin care putem repeta lista pentru a le face să funcționeze pentru un set de mostre mai mare.
Metode: Există mai multe moduri de a parcurge Lista. Cele mai faimoase moduri sunt folosirea modului de bază pentru buclă în combinație cu a metoda get(). pentru a obține elementul la un index specific și avansat pentru o buclă .
Exemplu:
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 + ' '); } }> |
>
>Ieșire
Geeks For Geeks Geeks For Geeks>
Metode ale interfeței Listă
Deoarece conceptul principal din spatele diferitelor tipuri de liste este același, interfața de listă conține următoarele metode:
| Metodă | Descriere |
|---|---|
| adaugă (index int, element) | Această metodă este utilizată cu Java List Interface pentru a adăuga un element la un anumit index din listă. Când un singur parametru este trecut, pur și simplu adaugă elementul la sfârșitul listei. |
| addAll(index int, colecție de colecție) | Această metodă este utilizată cu List Interface în Java pentru a adăuga toate elementele din colecția dată la listă. Când un singur parametru este trecut, acesta adaugă toate elementele colecției date la sfârșitul listei. |
| mărimea() | Această metodă este utilizată cu Java List Interface pentru a returna dimensiunea listei. |
| clar() | Această metodă este folosită pentru a elimina toate elementele din listă. Cu toate acestea, referința listei create este încă stocată. |
| elimina (index int) | Această metodă elimină un element din indexul specificat. Mută elementele ulterioare (dacă există) la stânga și le scade indicii cu 1. |
| elimina (element) | Această metodă este utilizată cu Java List Interface pentru a elimina prima apariție a elementului dat din listă. |
| get(index int) | Această metodă returnează elemente la indexul specificat. |
| set(index int, element) | Această metodă înlocuiește elementele de la un index dat cu noul element. Această funcție returnează elementul care tocmai a fost înlocuit cu un element nou. |
| indexOf(element) | Această metodă returnează prima apariție a elementului dat sau -1 dacă elementul nu este prezent în listă. |
| lastIndexOf(element) | Această metodă returnează ultima apariție a elementului dat sau -1 dacă elementul nu este prezent în listă. |
| este egal (element) | Această metodă este utilizată cu Java List Interface pentru a compara egalitatea elementului dat cu elementele listei. |
| hashCode() | Această metodă este utilizată cu List Interface în Java pentru a returna valoarea hashcode a listei date. |
| este gol() | Această metodă este utilizată cu Java List Interface pentru a verifica dacă lista este goală sau nu. Returnează adevărat dacă lista este goală, altfel fals. |
| conţine(element) | Această metodă este folosită cu List Interface în Java pentru a verifica dacă lista conține sau nu elementul dat. Returnează adevărat dacă lista conține elementul. |
| containsAll(Colecție de colecție) | Această metodă este utilizată cu Java List Interface pentru a verifica dacă lista conține toată colecția de elemente. |
| sortare (comparație de comparație) | Această metodă este utilizată cu List Interface în Java pentru a sorta elementele listei pe baza datei comparator . |
Lista Java vs Set
Atât interfața Listă, cât și interfața Set moștenesc interfața Collection. Cu toate acestea, există unele diferențe între ele.
| Listă | A stabilit |
|---|---|
| Lista este o secvență ordonată. | Setul este o secvență neordonată. |
| Lista permite elemente duplicate | Setul nu permite elemente duplicate. |
| Elementele după poziția lor pot fi accesate. | Accesul în poziție la elemente nu este permis. |
| Pot fi stocate mai multe elemente nule. | Elementul nul poate stoca o singură dată. |
| Implementările listelor sunt ArrayList, LinkedList, Vector, Stack | Implementările setului sunt HashSet, LinkedHashSet. |
Asocierea claselor cu o interfață de listă Java
Acum haideți să discutăm despre clasele care implementează Interfața Listă pentru care mai întâi se referă la reprezentarea picturală de mai jos pentru a înțelege mai bine interfața Listă. Este după cum urmează:
matematică.pow java
AbstractList , CopyOnWriteArrayList , si AbstractSequentialList sunt clasele care implementează interfața List. O funcționalitate separată este implementată în fiecare dintre clasele menționate. Acestea sunt după cum urmează:
- AbstractList: Această clasă este folosită pentru a implementa o listă nemodificabilă, pentru care trebuie doar să extindeți această clasă AbstractList și să implementați numai obține() si mărimea() metode.
- CopyOnWriteArrayList: Această clasă implementează interfața listă. Este o versiune îmbunătățită a ArrayList în care toate modificările (adăugați, setați, eliminați etc.) sunt implementate prin realizarea unei noi copii a listei.
- AbstractSequentialList: Această clasă implementează Interfață de colecție și clasa AbstractCollection. Această clasă este folosită pentru a implementa o listă nemodificabilă, pentru care trebuie doar să extindeți această clasă AbstractList și să implementați numai obține() si mărimea() metode.
Vom proceda în acest mod.
- ArrayList
- Vector
- Grămadă
- LinkedList
Să le discutăm secvențial și să implementăm același lucru pentru a ne da seama de funcționarea claselor cu interfața Listă.
1. ArrayList
O ArrayList clasa care este implementată în cadrul de colecție ne oferă matrice dinamice în Java. Cu toate acestea, poate fi mai lent decât matricele standard, dar poate fi util în programele în care este nevoie de multă manipulare în matrice. Să vedem cum să creăm un obiect listă folosind această clasă.
Exemplu:
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) + ' '); } }> |
>
>Ieșire
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
2. Vector
Vector este o clasă care este implementată în cadrul de colecție și implementează o serie de obiecte care poate crește. Vector implementează o matrice dinamică, ceea ce înseamnă că poate crește sau micșora după cum este necesar. Ca o matrice, conține componente care pot fi accesate folosind un index întreg. Vectorii se încadrează practic în clasele moștenite, dar acum este pe deplin compatibil cu colecțiile. Să vedem cum să creăm un obiect listă folosind această clasă.
Exemplu:
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) + ' '); } }> |
>
>Ieșire
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
3. Stiva
Stack este o clasă care este implementată în cadrul de colecție și extinde modelele de clasă vectorială și implementează Exemplu:
Java
Exemplu: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) + ' '); } }> |
>
>
cum să verificați dimensiunea ecranului monitoruluiIeșire
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
4. LinkedList
Exemplu:
Java
LinkedList este o clasă care este implementată în cadrul de colecție care implementează în mod inerent Exemplu:Java
Exemplu: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) + ' '); } }> |
>
>Ieșire
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>