Java saraksta saskarne nodrošina veidu, kā saglabāt pasūtīto kolekciju. Tā ir bērna saskarne Kolekcija . Tā ir sakārtota objektu kolekcija, kurā var saglabāt dublētās vērtības. Tā kā saraksts saglabā ievietošanas secību, tas nodrošina pozicionālu piekļuvi un elementu ievietošanu.
Satura rādītājs
- Saraksta interfeiss Java
- Java saraksta saskarnes deklarācija
- Java saraksta piemērs
- Darbības Java saraksta saskarnē
- Java saraksta saskarnes sarežģītība
- Iterācija, izmantojot saraksta interfeisu Java
- Saraksta saskarnes metodes
- Java saraksts vs komplekts
Saraksta interfeiss Java
Saraksta saskarne ir atrodama pakotnē java.util un pārmanto kolekcijas saskarni. Tā ir ListIterator interfeisa rūpnīca. Izmantojot ListIterator, mēs varam atkārtot sarakstu uz priekšu un atpakaļ. List interfeisa ieviešanas klases ir ArrayList, LinkedList, Stack un Vector. Java programmēšanā plaši izmanto ArrayList un LinkedList. Vector klase ir novecojusi kopš Java 5.
Saraksts un ArrayList Java kolekcijas sistēmā
Java saraksta saskarnes deklarācija
public interface List extends Collection ;>
Ļaujiet mums sīkāk izstrādāt objektu vai gadījumu izveidi List klasē. Kopš Saraksts ir saskarne , objektus nevar izveidot no tipu saraksta. Mums vienmēr ir vajadzīga klase, kas to īsteno Saraksts lai izveidotu objektu. Un arī pēc ieviešanas Generics Java 1.5 versijā ir iespējams ierobežot objektu veidu, ko var saglabāt sarakstā. Tāpat kā vairākas citas lietotāja definētas 'saskarnes', ko īsteno lietotāja definētas 'klases', Saraksts ir “interfeiss”, ko ieviesa ArrayList klase, iepriekš noteikta java.util iepakojums.
Java saraksta sintakse
Šāda veida drošo sarakstu var definēt kā:
List list = new ArrayList ();>
Piezīme: Obj ir sarakstā glabājamā objekta tips
Java saraksta piemērs
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);> >}> }> |
>
>Izvade
[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>
Tagad veiksim dažādas darbības, izmantojot saraksta interfeisu, lai labāk izprastu to pašu. Mēs apspriedīsim tālāk norādītās darbības un vēlāk to ieviešanu, izmantojot tīrus Java kodus.
Darbības Java saraksta saskarnē
Tā kā saraksts ir interfeiss, to var izmantot tikai ar klasi, kas ievieš šo saskarni. Tagad apskatīsim, kā sarakstā veikt dažas bieži izmantotās darbības.
- 1. darbība: Elementu pievienošana klasei List, izmantojot metodi add().
- 2. darbība: Elementu atjaunināšana klasē List, izmantojot set() metodi
- 3. darbība: Elementu meklēšana, izmantojot indexOf(), lastIndexOf metodes
- 4. darbība: Elementu noņemšana, izmantojot metodi remove().
- 5. darbība: Piekļuve elementiem klasē List, izmantojot metodi get().
- 6. darbība: Pārbaude, vai kāds elements atrodas klasē List, izmantojot include() metodi
Tagad apspriedīsim darbības atsevišķi un ieviesīsim to pašu kodā, lai labāk to uztvertu.
1. Elementu pievienošana klasei List, izmantojot add() metode
Lai sarakstam pievienotu elementu, mēs varam izmantot pievienot () metodi. Šī metode ir pārslogota, lai veiktu vairākas darbības, pamatojoties uz dažādiem parametriem.
Parametri: Tam nepieciešami 2 parametri, proti:
- pievienot (objekts): Šo metodi izmanto, lai saraksta beigās pievienotu elementu.
- add(int indekss, objekts): Šo metodi izmanto, lai pievienotu elementu noteiktā sarakstā sarakstā
Piemērs:
Java
kā atvērt failu java
// 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);> >}> }> |
>
>Izvade
[Geeks, For, Geeks]>
2. Elementu atjaunināšana
Pēc elementu pievienošanas, ja vēlamies elementu mainīt, to var izdarīt, izmantojot set() metodi. Tā kā saraksts ir indeksēts, uz elementu, kuru vēlamies mainīt, atsaucas ar elementa indeksu. Tāpēc šī metode izmanto indeksu un atjaunināto elementu, kas jāievieto šajā indeksā.
Piemērs:
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);> >}> }> |
>
>Izvade
Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>
3. Elementu meklēšana
Elementu meklēšana saskarnē List ir izplatīta Java programmēšanas darbība. Saraksta saskarne nodrošina vairākas metodes elementu meklēšanai, piemēram, indexOf() , LastIndexOf() metodes.
Metode indexOf() atgriež sarakstā norādītā elementa pirmās parādības indeksu, savukārt metode lastIndexOf() atgriež norādītā elementa pēdējās parādīšanās indeksu.
Parametri:
- indexOf(elements): Atgriež norādītā elementa pirmās parādīšanās indeksu sarakstā vai -1, ja elements nav atrasts
- lastIndexOf(elements): Atgriež norādītā elementa pēdējā sastopamības indeksu sarakstā vai -1, ja elements nav atrasts
Piemērs:
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);> >}> }> |
>
>Izvade
The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>
4. Elementu noņemšana
Lai noņemtu elementu no saraksta, mēs varam izmantot noņemt () metodi. Šī metode ir pārslogota, lai veiktu vairākas darbības, pamatojoties uz dažādiem parametriem. Viņi ir:
Parametri:
- noņemt (objekts): Šo metodi izmanto, lai vienkārši noņemtu objektu no saraksta. Ja ir vairāki šādi objekti, tiek noņemta pirmā objekta parādīšanās.
- noņemt(int indekss): Tā kā saraksts ir indeksēts, šī metode ņem vesela skaitļa vērtību, kas vienkārši noņem elementu, kas atrodas konkrētajā sarakstā sarakstā. Pēc elementa noņemšanas visi elementi tiek pārvietoti pa kreisi, lai aizpildītu vietu, un objektu indeksi tiek atjaunināti.
Piemērs:
Java
lejupielādēt autocad 2019 angļu mediafire
// 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);> >}> }> |
>
>Izvade
Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>
5. Piekļuve elementiem
Lai piekļūtu elementam sarakstā, mēs varam izmantot gūt() metode, kas atgriež elementu norādītajā indeksā
Parametri:
get(int index): šī metode atgriež elementu sarakstā norādītajā indeksā.
Piemērs:
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);> >}> }> |
>
>Izvade
Geeks For Geeks [Geeks, For, Geeks]>
6. Pārbauda, vai sarakstā ir kāds elements
Lai pārbaudītu, vai sarakstā ir kāds elements, mēs varam izmantot satur () metodi. Šī metode atgriež patieso vērtību, ja norādītais elements atrodas sarakstā, pretējā gadījumā tā atgriež false.
Parametri:
satur(Objekts): šī metode izmanto vienu parametru, objektu, kas jāpārbauda, ja tas ir sarakstā.
Piemērs:
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);> >}> }> |
saraksta izveide Java
>
>Izvade
Is Geeks present in the list? true>
Java saraksta saskarnes sarežģītība
| Darbība | Laika sarežģītība | Kosmosa sarežģītība |
|---|---|---|
| Elementa pievienošana saraksta saskarnē | O(1) | O(1) |
| Noņemiet elementu no saraksta saskarnes | O(N) | O(N) |
| Aizstāt elementu saraksta saskarnē | O(N) | O(N) |
| Traversing List Interfeiss | O(N) | O(N) |
Iterācija, izmantojot saraksta interfeisu Java
Līdz šim mums ir ļoti mazs ievades lielums, un mēs veicam darbības manuāli katrai entītijai. Tagad apspriedīsim dažādus veidus, kā mēs varam atkārtot sarakstu, lai tie darbotos lielākam paraugu kopumam.
Metodes: Ir vairāki veidi, kā atkārtot sarakstu. Slavenākie veidi ir pamata izmantošana cilpai kombinācijā ar a get() metode lai iegūtu elementu noteiktā indeksā un uzlabots par cilpu .
Piemērs:
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 + ' '); } }> |
>
>Izvade
Geeks For Geeks Geeks For Geeks>
Saraksta saskarnes metodes
Tā kā dažādu veidu sarakstu galvenā koncepcija ir vienāda, saraksta saskarnē ir šādas metodes:
| Metode | Apraksts |
|---|---|
| pievienot(indekss, elements) | Šī metode tiek izmantota kopā ar Java saraksta interfeisu, lai pievienotu elementu konkrētam saraksta indeksam. Kad tiek nodots viens parametrs, tas vienkārši pievieno elementu saraksta beigās. |
| pievienot visu (indekss, kolekcijas kolekcija) | Šo metodi izmanto Java saraksta interfeisā, lai sarakstam pievienotu visus noteiktās kolekcijas elementus. Kad tiek nodots viens parametrs, tas saraksta beigās pievieno visus dotās kolekcijas elementus. |
| Izmērs() | Šī metode tiek izmantota kopā ar Java saraksta interfeisu, lai atgrieztu saraksta lielumu. |
| skaidrs () | Šo metodi izmanto, lai noņemtu visus saraksta elementus. Tomēr izveidotā saraksta atsauce joprojām tiek saglabāta. |
| noņemt(int indekss) | Šī metode noņem elementu no norādītā indeksa. Tas pārvieto nākamos elementus (ja tādi ir) pa kreisi un samazina to indeksus par 1. |
| noņemt (elements) | Šī metode tiek izmantota ar Java saraksta interfeisu, lai sarakstā noņemtu pirmo dotā elementa gadījumu. |
| iegūt (indekss) | Šī metode atgriež elementus norādītajā indeksā. |
| kopa (indekss, elements) | Šī metode aizvieto elementus noteiktā indeksā ar jauno elementu. Šī funkcija atgriež elementu, kas tikko tika aizstāts ar jaunu elementu. |
| indexOf(elements) | Šī metode atgriež pirmo dotā elementa vai -1 ja elements nav iekļauts sarakstā. |
| pēdējaisIndekss(elements) | Šī metode atgriež pēdējo dotā elementa vai -1 ja elements nav iekļauts sarakstā. |
| vienāds(elements) | Šo metodi izmanto Java saraksta interfeisā, lai salīdzinātu dotā elementa vienlīdzību ar saraksta elementiem. |
| hashCode() | Šī metode tiek izmantota ar saraksta interfeisu Java, lai atgrieztu dotā saraksta jaucējkoda vērtību. |
| ir tukšs() | Šo metodi izmanto Java saraksta saskarnē, lai pārbaudītu, vai saraksts ir tukšs. Tas atgriež patiesu, ja saraksts ir tukšs, pretējā gadījumā atgriež false. |
| satur (elementu) | Šī metode tiek izmantota Java saraksta interfeisā, lai pārbaudītu, vai sarakstā ir norādītais elements. Tas atgriež patiesu, ja sarakstā ir elements. |
| satur visu (kolekciju kolekcija) | Šo metodi izmanto Java saraksta saskarnē, lai pārbaudītu, vai sarakstā ir visa elementu kolekcija. |
| kārtot (salīdzinājuma salīdzināšana) | Šī metode tiek izmantota Java saraksta interfeisā, lai kārtotu saraksta elementus, pamatojoties uz doto salīdzinātājs . |
Java saraksts vs komplekts
Gan saraksta saskarne, gan saskarne Set manto kolekcijas saskarni. Tomēr starp tām pastāv dažas atšķirības.
| Saraksts | Iestatīt |
|---|---|
| Saraksts ir sakārtota secība. | Komplekts ir nesakārtota secība. |
| Saraksts ļauj dublēt elementus | Iestatījums neatļauj dublēt elementus. |
| Var piekļūt elementiem pēc to atrašanās vietas. | Pozīcijas piekļuve elementiem nav atļauta. |
| Var saglabāt vairākus nulles elementus. | Nulles elementu var saglabāt tikai vienu reizi. |
| Sarakstu ieviešanas ir ArrayList, LinkedList, Vector, Stack | Kopu ieviešanas ir HashSet, LinkedHashSet. |
Klašu saistība ar Java saraksta interfeisu
Tagad apspriedīsim klases, kas ievieš saraksta interfeisu, kurām vispirms atsaucieties uz tālāk redzamo attēlu, lai labāk izprastu saraksta saskarni. Tas ir šādi:
AbstractList , CopyOnWriteArrayList , un AbstractSequentialList ir klases, kas ievieš List interfeisu. Katrā no minētajām klasēm tiek realizēta atsevišķa funkcionalitāte. Tie ir šādi:
- AbstractList: Šī klase tiek izmantota, lai ieviestu nemodificētu sarakstu, kuram ir jāpaplašina tikai šī AbstractList klase un jāievieš tikai gūt() un Izmērs() metodes.
- CopyOnWriteArrayList: Šī klase ievieš saraksta saskarni. Tā ir uzlabota versija ArrayList kurā visas modifikācijas (pievienot, iestatīt, noņemt utt.) tiek ieviestas, izveidojot jaunu saraksta kopiju.
- AbstractSequentialList: Šī klase īsteno Kolekcijas saskarne un AbstractCollection klase. Šī klase tiek izmantota, lai ieviestu nemodificētu sarakstu, kuram ir jāpaplašina tikai šī AbstractList klase un jāievieš tikai gūt() un Izmērs() metodes.
Mēs turpināsim šādā veidā.
- ArrayList
- Vektors
- Kaudze
- LinkedList
Apspriedīsim tos secīgi un ieviesīsim to pašu, lai noskaidrotu klašu darbību ar List interfeisu.
1. ArrayList
ArrayList klase, kas ir ieviesta kolekcijas sistēmā, nodrošina mums dinamiskus masīvus Java. Tomēr tas var būt lēnāks nekā standarta masīvi, taču tas var būt noderīgs programmās, kurās ir nepieciešams daudz manipulēt ar masīvu. Apskatīsim, kā izveidot saraksta objektu, izmantojot šo klasi.
Piemērs:
Java
formāta java virkne
// 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) + ' '); } }> |
>
>Izvade
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
2. Vektors
Vector ir klase, kas ir ieviesta kolekcijas ietvarā, kas īsteno paplašināmu objektu masīvu. Vector ievieš dinamisku masīvu, kas nozīmē, ka tas var augt vai sarukt pēc vajadzības. Tāpat kā masīvā, tajā ir komponenti, kuriem var piekļūt, izmantojot veselu skaitļu indeksu. Vektori pamatā ietilpst mantotās klasēs, taču tagad tie ir pilnībā saderīgi ar kolekcijām. Apskatīsim, kā izveidot saraksta objektu, izmantojot šo klasi.
Piemērs:
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) + ' '); } }> |
>
>Izvade
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
3. Sakraut
Stack ir klase, kas ir ieviesta kolekcijas sistēmā un paplašina vektoru klašu modeļus un ievieš Piemērs:
Java
Piemērs: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) + ' '); } }> |
>
>Izvade
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
4. LinkedList
Piemērs:
Java
LinkedList ir klase, kas ir ieviesta savākšanas sistēmā, kas pēc būtības ievieš Piemērs:Java
Piemērs:Java
atšķirība starp lapsu un vilku
// 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) + ' '); } }> |
>
>Izvade
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>