Java-luetteloiden avulla voimme ylläpitää järjestettyä objektikokoelmaa. Päällekkäisiä elementtejä sekä nollaelementtejä voidaan myös tallentaa luetteloon Javassa. List-käyttöliittymä on osa java.util paketti ja se perii Collection-rajapinnan. Se säilyttää lisäysjärjestyksen.

Javassa on useita tapoja iteroida Listissä. Niitä käsitellään alla:

Menetelmät:

1. Silmukoiden käyttö (naiivi lähestymistapa)
   • Silmukalle
   • Jokaista silmukkaa varten
   • Vaikka silmukka
2. Käyttämällä Iteraattori
3. Käyttämällä Lista iteraattori
4. Lambda-lausekkeen käyttö
5. Käyttämällä stream.forEach()
6. Spliteratorin käyttäminen (Java 8 ja uudemmat)

Menetelmä 1-A: Yksinkertainen silmukalle

Jokaista elementtiä voidaan käyttää iteroimalla käyttämällä yksinkertaista for-silmukkaa. Indeksiin pääsee käsiksi käyttämällä indeksiä silmukkamuuttujana.

Syntaksi:

for (i = 0; i>

Alla on esimerkki tästä menetelmästä:

// Java Program to iterate over List // Using simple for loop // Importing all classes of // java.util package import java.util.*; // CLass class GFG {  // Main driver method  public static void main(String args[])  {  // Creating a ArrayList  ListmyList = uusi ArrayList();  // Elementtien lisääminen luetteloon // Mukautetut syötteet myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Silmukalle, jolla iteroidaan List for (int i = 0; i< myList.size(); i++) {  // Print all elements of List  System.out.println(myList.get(i));  }  } }>

A B C D>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n), missä 'n' on luettelon koko.
Aputila: O(1), Silmukkamuuttujille (tässä tapauksessa i) käytetään vakioavaruutta.

Tapa 1-B: Parannettu silmukalle

Jokaista elementtiä voidaan käyttää iteroimalla käyttämällä parannettua silmukkaa. Tämä silmukka otettiin käyttöön J2SE 5.0:ssa. Se on vaihtoehtoinen tapa kulkea for a silmukan läpi. Se tekee koodista luettavamman.

Syntaksi:

for(data_type variable : List_name) { // Body of the loop. // Each element can be accessed using variable. }>

Alla on esimerkki tästä menetelmästä:

// Java Program to Iterate over a List // using enhanced for loop (for-each) // Importing all classes of // java.util package import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist  ListmyList = uusi ArrayList();  // Elementtien lisääminen listaan ​​// Mukautetut syötteet myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Enhanced for loop(for-each) käyttäminen iteraatiossa kohteelle (String i : myList) { // Tulosta kaikki ArrayList-elementit System.out.println(i);  } } }>

A B C D>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n), missä 'n' on luettelon koko.
Aputila: O(1), Silmukkamuuttujille (tässä tapauksessa i) käytetään vakioavaruutta.

Menetelmä 1-C: Käytä while-silmukkaa

Listan iterointi voidaan saavuttaa myös while-silmukalla. Silmukan sisällä oleva koodilohko suoritetaan, kunnes ehto on tosi. Silmukkamuuttujaa voidaan käyttää an hakemistoon päästäksesi jokaiseen elementtiin.

Syntaksi:

while(variable>

Alla on esimerkki tästä menetelmästä:

// Java Program to iterate over a List // using while loop // Importing all classes of // java.util package import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = uusi ArrayList();  // Elementtien lisääminen listaan ​​// Mukautetut syötteet myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Minkä tahansa muuttujan alustaminen arvoon 0 int i = 0;  // Jos muuttujan arvo on pienempi kuin // arvo ilmaisee listan koon while (i< myList.size()) {  // Print element of list  System.out.println(myList.get(i));  // Increase variable count by 1  i++;  }  } }>

A B C D>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n), missä 'n' on luettelon koko.
Aputila : O(1), Silmukkamuuttujille (tässä tapauksessa i) käytetään vakioavaruutta.

Tapa 2: Iteraattorin käyttö

Iteraattori on Java-objekti, joka mahdollistaa iteroinnin kokoelman elementtien yli. Jokaiseen luettelon elementtiin pääsee käsiksi iteraattorilla, jossa on while-silmukka.

Syntaksi:

Iterator variable = list_name.iterator();>

Alla on esimerkki tästä menetelmästä:

// Java Program to iterate over the list // using iterator // Importing all classes of // java.util package import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = uusi ArrayList();  // Elementtien lisääminen listaan ​​// Mukautetut syötteet myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Iteraattori Iteraattoriit = myList.iterator();  // Listan elementtien ehtotarkistus // hasNext()-metodilla palauttaen true till // Listassa on yksi elementti while (it.hasNext()) { // Tulosta kaikki listan elementit System.out.println(it .Seuraava());  } } }>

A B C D>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n), missä 'n' on luettelon koko.
Aputila: O(1), Silmukkamuuttujille (tässä tapauksessa i) käytetään vakioavaruutta.

Tapa 3: List-iteraattorin käyttäminen

ListIterator on Java-iteraattori, joka on saatavilla 1.2-versiosta lähtien. Sen avulla voimme iteroida elementtejä yksitellen List-toteutetun objektin. Sitä käytetään iteroimaan luetteloa käyttäen while-silmukkaa.

Syntaksi:

ListIterator variable = list_name.listIterator();>

Alla on esimerkki tästä menetelmästä:

// Java program to iterate over a list // using ListIterator import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = uusi ArrayList();  // Elementtien lisääminen listaan ​​// Mukautetut syötteet myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Listaiteraattori ListIteratorit = myList.listIterator();  // Ehto tarkista onko listassa elementtiä // komennolla hasNext() joka pätee siihen asti // Listassa on yksi elementti while (it.hasNext()) { // Tulosta listan kaikki elementit System.out.println( se.seuraava());  } } }>

A B C D>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n), missä 'n' on luettelon koko.
Aputila: O(1), Silmukkamuuttujille (tässä tapauksessa i) käytetään vakioavaruutta.

Tapa 4: Iterable.forEach()

Tämä ominaisuus on saatavilla Java 8:sta lähtien. Sitä voidaan käyttää myös iterointiin listan yli. Iterointi voidaan tehdä käyttämällä a lambda ilmaisu.

Syntaksi:

list_name.forEach(variable->{//koodilohko})>

Alla on esimerkki tästä menetelmästä:

// Java Program to iterate over a List // using forEach() // Importing all classes of // java.util method import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = uusi ArrayList();  // Elementtien lisääminen listaan ​​// Mukautetut syötteet myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Lambdalauseke tulostaa kaikki listan elementit myList.forEach( (temp) -> { System.out.println(temp); });  } }>

A B C D>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n), missä 'n' on luettelon koko.
Aputila: O(1), Silmukkamuuttujille (tässä tapauksessa i) käytetään vakioavaruutta.

Tapa 5: Stream.forEach()

Kohteen stream().forEach() käsittelyjärjestys on määrittelemätön, kun taas forEach():n tapauksessa se on määritelty. Molempia voidaan käyttää iteroimaan listan yli.

Syntaksi:

list_name.stream.forEach(variable->{//koodilohko})>

Alla on esimerkki tästä menetelmästä:

// Java Program iterating over a List // using stream.forEach() method // Importing all classes of // java.util method import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = uusi ArrayList();  // Elementtien lisääminen listaan ​​// Mukautetut syötteet myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // stream.forEach() -menetelmä tulostaa // kaikki listan elementit myList.stream().forEach( (temp) -> System.out.println(temp));  } }>

A B C D>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n), missä 'n' on luettelon koko.
Aputila: O(1), Silmukkamuuttujille (tässä tapauksessa i) käytetään vakioavaruutta.

tuple java

Menetelmät 6: Spliteratorin käyttö (Java 8 ja uudemmat)

Java 8 esitteli Jakaja käyttöliittymä, joka tulee sanoista split iterator. Se tarjoaa tavan toistaa elementtejä rinnakkaisystävällisemmällä tavalla. Splitterator voidaan hankkia useista lähteistä, mukaan lukien kokoelmista, kuten luetteloista. Spliteratorin forEachRemaining-menetelmää käytetään kaikkien jäljellä olevien elementtien läpikulkuun peräkkäin.

Syntaksi:

Spliterator spliterator = myList.spliterator();>

Alla on esimerkki tästä menetelmästä:

// Java Program iterating over a List // using Spliterator import java.util.List; import java.util.Spliterator; public class ListIteration {  public static void main(String[] args) {  // List of String  ListmyList = List.of('A', 'B', 'C','D');    // Spliterator Spliteratorin käyttöspliterator = myList.spliterator();  spliterator.forEachRemaining(System.out::println);  } }>

A B C D>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n), missä 'n' on luettelon koko.
Aputila: O(log n) tai O(1), (riippuen Spliterator-toteutuksen ominaisuuksista)