Listor i Java tillåter oss att upprätthålla en ordnad samling av objekt. Dubblettelement såväl som nullelement kan också lagras i en lista i Java. Listgränssnittet är en del av java.util paketet och det ärver samlingsgränssnittet. Den bevarar insättningsordningen.
Det finns flera sätt att iterera över List i Java. De diskuteras nedan:
Metoder:
- Använda loopar (naivt tillvägagångssätt)
- Använder sig av Iterator
- Använder sig av Lista iterator
- Använder lambda-uttryck
- Använder sig av stream.forEach()
- Använda Spliterator (Java 8 och senare)
Metod 1-A: Enkel för loop
Varje element kan nås genom iteration med en enkel för loop. Indexet kan nås med hjälp av indexet som en loopvariabel.
Syntax:
statisk i c
for (i = 0; i>
Nedan är ett exempel på denna metod:
Java
// 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 = ny ArrayList(); // Lägga till element i listan // Anpassade ingångar myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // För loop för iterering över listan för (int i = 0; i< myList.size(); i++) { // Print all elements of List System.out.println(myList.get(i)); } } }> Produktion
A B C D>
Ovanstående metods komplexitet:
Tidskomplexitet: O(n), där 'n' är storleken på listan.
Hjälputrymme: O(1), konstant utrymme används för loopvariabler (i i detta fall).
Metod 1-B: Förbättrad för loop
Varje element kan nås genom iteration med en förbättrad för-loop. Denna loop introducerades i J2SE 5.0. Det är ett alternativt tillvägagångssätt att korsa för en slinga. Det gör koden mer läsbar.
Syntax:
for(data_type variable : List_name) { // Body of the loop. // Each element can be accessed using variable. }>Nedan är ett exempel på denna metod:
Java // 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 = ny ArrayList(); // Lägga till element i listan // Custom inputs myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Använda enhanced for loop(for-each) för iteration för (String i : myList) { // Skriv ut alla element i ArrayList System.out.println(i); } } }> Produktion
A B C D>
Ovanstående metods komplexitet:
Tidskomplexitet: O(n), där 'n' är storleken på listan.
Hjälputrymme: O(1), konstant utrymme används för loopvariabler (i i detta fall).
Metod 1-C: Använd en while-loop
Iteration över en lista kan också uppnås med en while-loop. Kodblocket inuti slingan körs tills villkoret är sant. En loopvariabel kan användas som en index för att komma åt varje element.
Syntax:
om av rudyard kipling rad för rad förklaring
while(variable>
Nedan är ett exempel på denna metod:
Java // 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 = ny ArrayList(); // Lägga till element i listan // Custom inputs myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Initialisera valfri variabel till 0 int i = 0; // Om variabelvärdet är mindre än // värdet anger storleken på List medan (dvs< myList.size()) { // Print element of list System.out.println(myList.get(i)); // Increase variable count by 1 i++; } } }> Produktion
A B C D>
Ovanstående metods komplexitet:
Tidskomplexitet: O(n), där 'n' är storleken på listan.
Hjälputrymme : O(1), konstant utrymme används för loopvariabler (i i detta fall).
Metod 2: Använd iterator
En iterator är ett objekt i Java som tillåter iteration över element i en samling. Varje element i listan kan nås med iterator med en while-loop.
Syntax:
Iterator variable = list_name.iterator();>
Nedan är ett exempel på denna metod:
Java // 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 = ny ArrayList(); // Lägga till element i listan // Custom inputs myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Iterator Iteratorit = myList.iterator(); // Villkorskontroll för element i List // använder metoden hasNext() som returnerar true till // det finns ett enda element i en List while (it.hasNext()) { // Skriv ut alla element i List System.out.println(it) .Nästa()); } } }> Produktion
A B C D>
Ovanstående metods komplexitet:
git status -s
Tidskomplexitet: O(n), där 'n' är storleken på listan.
Hjälputrymme: O(1), konstant utrymme används för loopvariabler (i i detta fall).
Metod 3: Använd listiterator
ListIterator är en iterator i Java som är tillgänglig sedan version 1.2. Det tillåter oss att iterera element en efter en från ett List-implementerat objekt. Den används för att iterera över en lista med while-loop.
Syntax:
ListIterator variable = list_name.listIterator();>
Nedan är ett exempel på denna metod:
Java // 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 = ny ArrayList(); // Lägga till element i listan // Custom inputs myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Listiterator ListIteratorit = myList.listIterator(); // Villkor kontrollera om det finns element i List // med hasNext() som gäller tills // det finns ett enda element i List while (it.hasNext()) { // Skriv ut alla element i List System.out.println( it.next()); } } }> Produktion
A B C D>
Ovanstående metods komplexitet:
försök catch block java
Tidskomplexitet: O(n), där 'n' är storleken på listan.
Hjälputrymme: O(1), konstant utrymme används för loopvariabler (i i detta fall).
Metod 4: Använd Iterable.forEach()
Denna funktion är tillgänglig sedan Java 8. Den kan också användas för att iterera över en lista. Iteration kan göras med hjälp av a lambda uttryck.
Syntax:
list_name.forEach(variable->{//kodblock})>Nedan är ett exempel på denna metod:
Java // 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 = ny ArrayList(); // Lägga till element i listan // Custom inputs myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Lambdauttryck som skriver ut alla element i en List myList.forEach( (temp) -> { System.out.println(temp); }); } }> Produktion
A B C D>
Ovanstående metods komplexitet:
Tidskomplexitet: O(n), där 'n' är storleken på listan.
Hjälputrymme: O(1), konstant utrymme används för loopvariabler (i i detta fall).
Metod 5: Använd Stream.forEach()
Bearbetningsordningen för stream().forEach() är odefinierad medan den är definierad i fallet med forEach(). Båda kan användas för att iterera över en lista.
Syntax:
typ i java
list_name.stream.forEach(variable->{//kodblock})>Nedan är ett exempel på denna metod:
Java // 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 = ny ArrayList(); // Lägga till element i listan // Custom inputs myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // stream.forEach()-metoden skriver ut // alla element i en List myList.stream().forEach( (temp) -> System.out.println(temp)); } }> Produktion
A B C D>
Ovanstående metods komplexitet:
Tidskomplexitet: O(n), där 'n' är storleken på listan.
Hjälputrymme: O(1), konstant utrymme används för loopvariabler (i i detta fall).
Metod 6: Använda Spliterator (Java 8 och senare)
Java 8 introducerade Spliterator gränssnitt, som står för split iterator. Det ger ett sätt att iterera över element på ett mer parallellvänligt sätt. En Spliterator kan erhållas från olika källor, inklusive samlingar som listor. ForEachRemaining-metoden i Spliterator används för att gå igenom alla återstående element sekventiellt.
Syntax:
Spliterator spliterator = myList.spliterator();>
Nedan är ett exempel på denna metod:
Java // 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'); // Använda Spliterator Spliteratorspliterator = myList.spliterator(); spliterator.forEachRemaining(System.out::println); } }> Produktion
A B C D>
Ovanstående metods komplexitet:
Tidskomplexitet: O(n), där 'n' är storleken på listan.
Hjälputrymme: O(log n) eller O(1), (beroende på egenskaperna hos Spliterator-implementeringen)