Listy w Javie pozwalają nam zachować uporządkowaną kolekcję obiektów. Zduplikowane elementy, a także elementy zerowe mogą być również przechowywane na liście w Javie. Interfejs Listy jest częścią java.util pakiet i dziedziczy interfejs Kolekcji. Zachowuje kolejność wstawiania.
Istnieje kilka sposobów iteracji po liście w Javie. Omówiono je poniżej:
Metody:
- Korzystanie z pętli (podejście naiwne)
- Za pomocą Iterator
- Za pomocą Iterator listy
- Korzystanie z wyrażenia lambda
- Za pomocą strumień.forEach()
- Korzystanie z Spliteratora (Java 8 i nowsze wersje)
Metoda 1-A: Prosta pętla for
Dostęp do każdego elementu można uzyskać poprzez iterację za pomocą prostej pętli for. Dostęp do indeksu można uzyskać za pomocą indeksu jako zmiennej pętli.
Składnia:
for (i = 0; i>
Poniżej znajduje się przykład tej metody:
Jawa
// 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 ListmojaList = nowa ArrayList(); // Dodawanie elementów do listy // Własne dane wejściowe myList.add('A'); mojaLista.add('B'); mojaLista.add('C'); mojaLista.add('D'); // Pętla For do iteracji po liście for (int i = 0; i< myList.size(); i++) { // Print all elements of List System.out.println(myList.get(i)); } } }> Wyjście
A B C D>
Złożoność powyższej metody:
Złożoność czasowa: O(n), gdzie „n” to rozmiar listy.
Przestrzeń pomocnicza: O(1), Stała przestrzeń jest używana dla zmiennych pętli (w tym przypadku i).
Metoda 1-B: Ulepszona pętla for
Dostęp do każdego elementu można uzyskać poprzez iterację przy użyciu ulepszonej pętli for. Pętla ta została wprowadzona w J2SE 5.0. Jest to alternatywne podejście do przechodzenia przez pętlę for. Dzięki temu kod jest bardziej czytelny.
Składnia:
for(data_type variable : List_name) { // Body of the loop. // Each element can be accessed using variable. }>Poniżej znajduje się przykład tej metody:
Jawa // 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 ListmojaList = nowa ArrayList(); // Dodawanie elementów do listy // Własne dane wejściowe myList.add('A'); mojaLista.add('B'); mojaLista.add('C'); mojaLista.add('D'); // Użycie ulepszonej pętli for (for-each) do iteracji dla (String i : myList) { // Wydrukuj wszystkie elementy ArrayList System.out.println(i); } } }> Wyjście
A B C D>
Złożoność powyższej metody:
Złożoność czasowa: O(n), gdzie „n” to rozmiar listy.
Przestrzeń pomocnicza: O(1), Stała przestrzeń jest używana dla zmiennych pętli (w tym przypadku i).
Metoda 1-C: Użycie pętli while
Iterację po liście można również wykonać za pomocą pętli while. Blok kodu wewnątrz pętli jest wykonywany, dopóki warunek nie zostanie spełniony. Zmienna pętli może być używana jako jakiś indeks, aby uzyskać dostęp do każdego elementu.
Składnia:
while(variable>
Poniżej znajduje się przykład tej metody:
Jawa // 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 ListmojaList = nowa ArrayList(); // Dodawanie elementów do listy // Własne dane wejściowe myList.add('A'); mojaLista.add('B'); mojaLista.add('C'); mojaLista.add('D'); // Inicjalizacja dowolnej zmiennej na 0 int i = 0; // Jeśli wartość zmiennej jest mniejsza niż // wartość wskazująca rozmiar Listy podczas (tj< myList.size()) { // Print element of list System.out.println(myList.get(i)); // Increase variable count by 1 i++; } } }> Wyjście
A B C D>
Złożoność powyższej metody:
Złożoność czasowa: O(n), gdzie „n” to rozmiar listy.
Przestrzeń pomocnicza : O(1), Dla zmiennych pętli (w tym przypadku i) używana jest stała spacja.
Metoda 2: Użycie iteratora
Iterator to obiekt w Javie, który umożliwia iterację po elementach kolekcji. Dostęp do każdego elementu listy można uzyskać za pomocą iteratora z pętlą while.
ile miast jest w nas
Składnia:
Iterator variable = list_name.iterator();>
Poniżej znajduje się przykład tej metody:
Jawa // 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 ListmojaList = nowa ArrayList(); // Dodawanie elementów do listy // Własne dane wejściowe myList.add('A'); mojaLista.add('B'); mojaLista.add('C'); mojaLista.add('D'); // Iterator Iteratorit = mojaLista.iterator(); // Sprawdzanie warunków elementów na liście // przy użyciu metody hasNext() zwracającej wartość true do // na liście znajduje się pojedynczy element while (it.hasNext()) { // Wydrukuj wszystkie elementy listy System.out.println(it .Następny()); } } }> Wyjście
A B C D>
Złożoność powyższej metody:
Złożoność czasowa: O(n), gdzie „n” to rozmiar listy.
Przestrzeń pomocnicza: O(1), Stała przestrzeń jest używana dla zmiennych pętli (w tym przypadku i).
Metoda 3: Używanie iteratora listy
ListIterator to iterator w Javie dostępny od wersji 1.2. Pozwala nam iterować elementy jeden po drugim z zaimplementowanego obiektu List. Służy do iteracji listy za pomocą pętli while.
Składnia:
ListIterator variable = list_name.listIterator();>
Poniżej znajduje się przykład tej metody:
Jawa // 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 ListmojaList = nowa ArrayList(); // Dodawanie elementów do listy // Własne dane wejściowe myList.add('A'); mojaLista.add('B'); mojaLista.add('C'); mojaLista.add('D'); // Iterator listy ListIteratorit = mojaList.listIterator(); // Sprawdzanie warunku, czy na liście znajduje się element // przy użyciu funkcji hasNext(), która obowiązuje do // gdy na liście znajduje się pojedynczy element while (it.hasNext()) { // Wydrukuj wszystkie elementy listy System.out.println( it.next()); } } }> Wyjście
A B C D>
Złożoność powyższej metody:
Złożoność czasowa: O(n), gdzie „n” to rozmiar listy.
Przestrzeń pomocnicza: O(1), Stała przestrzeń jest używana dla zmiennych pętli (w tym przypadku i).
Metoda 4: Używanie Iterable.forEach()
Ta funkcja jest dostępna od wersji Java 8. Można jej również używać do iteracji po liście. Iterację można wykonać za pomocą A wyrażenie lambda.
Składnia:
list_name.forEach(variable->//blok kodu})>
Poniżej znajduje się przykład tej metody:
Jawa // 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 ListmojaList = nowa ArrayList(); // Dodawanie elementów do listy // Własne dane wejściowe myList.add('A'); mojaLista.add('B'); mojaLista.add('C'); mojaLista.add('D'); // Wyrażenie Lambda drukujące wszystkie elementy listy myList.forEach( (temp) -> { System.out.println(temp); }); } }> Wyjście
A B C D>
Złożoność powyższej metody:
Złożoność czasowa: O(n), gdzie „n” to rozmiar listy.
Przestrzeń pomocnicza: O(1), Stała przestrzeń jest używana dla zmiennych pętli (w tym przypadku i).
Metoda 5: Korzystanie ze Stream.forEach()
Kolejność przetwarzania stream().forEach() jest niezdefiniowana, natomiast w przypadku forEach() jest zdefiniowana. Obydwa mogą być używane do iteracji po liście.
Składnia:
list_name.stream.forEach(variable->{//blok kodu})>Poniżej znajduje się przykład tej metody:
Jawa // 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 ListmojaList = nowa ArrayList(); // Dodawanie elementów do listy // Własne dane wejściowe myList.add('A'); mojaLista.add('B'); mojaLista.add('C'); mojaLista.add('D'); // metoda stream.forEach() wypisuje // wszystkie elementy wewnątrz listy myList.stream().forEach( (temp) -> System.out.println(temp)); } }> Wyjście
A B C D>
Złożoność powyższej metody:
pierwszeństwo operatora Java
Złożoność czasowa: O(n), gdzie „n” to rozmiar listy.
Przestrzeń pomocnicza: O(1), Stała przestrzeń jest używana dla zmiennych pętli (w tym przypadku i).
Metody 6: Korzystanie z Spliteratora (Java 8 i nowsze wersje)
W Javie 8 wprowadzono Rozdzielacz interfejs, co oznacza podzielony iterator. Zapewnia sposób iteracji po elementach w sposób bardziej równoległy. Spliterator można uzyskać z różnych źródeł, w tym z kolekcji takich jak listy. Metoda forEachRemaining Spliteratora służy do sekwencyjnego przechodzenia przez wszystkie pozostałe elementy.
Składnia:
Spliterator spliterator = myList.spliterator();>
Poniżej znajduje się przykład tej metody:
Jawa // 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 ListmojaList = Lista.of('A', 'B', 'C','D'); // Korzystanie z rozdzielacza Rozdzielaczspliterator = mojaLista.spliterator(); spliterator.forEachRemaining(System.out::println); } }> Wyjście
A B C D>
Złożoność powyższej metody:
Złożoność czasowa: O(n), gdzie „n” to rozmiar listy.
Przestrzeń pomocnicza: O(log n) lub O(1), (w zależności od charakterystyki implementacji Spliteratora)