Seznamy v Javě nám umožňují udržovat uspořádanou kolekci objektů. Duplicitní prvky i nulové prvky lze také uložit do seznamu v Javě. Rozhraní Seznam je součástí java.util balíček a zdědí rozhraní kolekce. Zachovává pořadí vkládání.
co je myspace
Existuje několik způsobů, jak iterovat přes List v Javě. Jsou diskutovány níže:
Metody:
- Používání smyček (naivní přístup)
- Použitím Iterátor
- Použitím Iterátor seznamu
- Použití výrazu lambda
- Použitím stream.forEach()
- Použití Spliteratoru (Java 8 a novější)
Metoda 1-A: Jednoduchá smyčka for
Ke každému prvku lze přistupovat iterací pomocí jednoduché smyčky for. K indexu lze přistupovat pomocí indexu jako proměnné smyčky.
Syntax:
for (i = 0; i>
Níže je uveden příklad této metody:
Jáva
// 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 = nový ArrayList(); // Přidání prvků do seznamu // Vlastní vstupy myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Cyklus For pro iteraci přes List for (int i = 0; i< myList.size(); i++) { // Print all elements of List System.out.println(myList.get(i)); } } }> Výstup
A B C D>
Složitost výše uvedené metody:
Časová náročnost: O(n), kde „n“ je velikost seznamu.
Pomocný prostor: O(1), Konstantní prostor se používá pro proměnné smyčky (v tomto případě i).
Metoda 1-B: Vylepšená smyčka for
Ke každému prvku lze přistupovat iterací pomocí vylepšené smyčky for. Tato smyčka byla představena v J2SE 5.0. Je to alternativní přístup k procházení smyčky for. Díky tomu je kód čitelnější.
Syntax:
for(data_type variable : List_name) { // Body of the loop. // Each element can be accessed using variable. }>Níže je uveden příklad této metody:
Jáva // 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 = nový ArrayList(); // Přidání prvků do seznamu // Vlastní vstupy myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Použití vylepšené smyčky for (for-each) pro iteraci for (String i : myList) { // Tisk všech prvků ArrayList System.out.println(i); } } }> Výstup
A B C D>
Složitost výše uvedené metody:
Časová náročnost: O(n), kde „n“ je velikost seznamu.
Pomocný prostor: O(1), Konstantní prostor se používá pro proměnné smyčky (v tomto případě i).
Metoda 1-C: Použití smyčky while
Iteraci nad seznamem lze také dosáhnout pomocí smyčky while. Blok kódu uvnitř smyčky se provádí, dokud není podmínka pravdivá. Proměnnou smyčky lze použít jako an index pro přístup ke každému prvku.
Syntax:
while(variable>
Níže je uveden příklad této metody:
Jáva // 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 = nový ArrayList(); // Přidání prvků do seznamu // Vlastní vstupy myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Inicializace libovolné proměnné na 0 int i = 0; // Pokud je hodnota proměnné menší než // hodnota udávající velikost List while (i< myList.size()) { // Print element of list System.out.println(myList.get(i)); // Increase variable count by 1 i++; } } }> Výstup
A B C D>
Složitost výše uvedené metody:
jak proměnit řetězec v int
Časová náročnost: O(n), kde „n“ je velikost seznamu.
Pomocný prostor : O(1), Konstantní prostor se používá pro proměnné smyčky (v tomto případě i).
Metoda 2: Použití iterátoru
Iterátor je objekt v Javě, který umožňuje iteraci prvků kolekce. Ke každému prvku v seznamu lze přistupovat pomocí iterátoru se smyčkou while.
jak zjistím velikost monitoru
Syntax:
Iterator variable = list_name.iterator();>
Níže je uveden příklad této metody:
Jáva // 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 = nový ArrayList(); // Přidání prvků do seznamu // Vlastní vstupy myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Iterátor Iterátorit = myList.iterator(); // Kontrola stavu prvků v seznamu // pomocí metody hasNext() vrací true, dokud // v seznamu není jeden prvek while (it.hasNext()) { // Tisk všech prvků seznamu System.out.println(it .další()); } } }> Výstup
A B C D>
Složitost výše uvedené metody:
Časová náročnost: O(n), kde „n“ je velikost seznamu.
Pomocný prostor: O(1), Konstantní prostor se používá pro proměnné smyčky (v tomto případě i).
Metoda 3: Použití iterátoru seznamu
ListIterator je iterátor v Javě, který je dostupný od verze 1.2. Umožňuje nám iterovat prvky jeden po druhém z objektu implementovaného seznamu. Používá se k iteraci seznamu pomocí cyklu while.
Syntax:
ListIterator variable = list_name.listIterator();>
Níže je uveden příklad této metody:
Jáva // 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 = nový ArrayList(); // Přidání prvků do seznamu // Vlastní vstupy myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Seznam iterátor ListIteratorit = myList.listIterator(); // Kontrola podmínky, zda je prvek v seznamu // pomocí hasNext(), který platí, dokud // v seznamu není jeden prvek while (it.hasNext()) { // Tisk všech prvků seznamu System.out.println( it.next()); } } }> Výstup
A B C D>
Složitost výše uvedené metody:
jak převést celé číslo na řetězec java
Časová náročnost: O(n), kde „n“ je velikost seznamu.
Pomocný prostor: O(1), Konstantní prostor se používá pro proměnné smyčky (v tomto případě i).
Metoda 4: Použití Iterable.forEach()
Tato funkce je dostupná od Java 8. Lze ji také použít k iteraci seznamu. Iteraci lze provést pomocí A lambda výraz.
Syntax:
list_name.forEach(variable->{//blok kódu})>Níže je uveden příklad této metody:
Jáva // 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 = nový ArrayList(); // Přidání prvků do seznamu // Vlastní vstupy myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Lambda výraz tisk všech prvků v seznamu myList.forEach( (temp) -> { System.out.println(temp); }); } }> Výstup
A B C D>
Složitost výše uvedené metody:
Časová náročnost: O(n), kde „n“ je velikost seznamu.
Pomocný prostor: O(1), Konstantní prostor se používá pro proměnné smyčky (v tomto případě i).
Metoda 5: Použití Stream.forEach()
Pořadí zpracování stream().forEach() není definováno, zatímco v případě forEach() je definováno. Obojí lze použít k iteraci seznamu.
Syntax:
list_name.stream.forEach(variable->{//blok kódu})>Níže je uveden příklad této metody:
Jáva // 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 = nový ArrayList(); // Přidání prvků do seznamu // Vlastní vstupy myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // metoda stream.forEach() vypíše // všechny prvky v seznamu List myList.stream().forEach( (temp) -> System.out.println(temp)); } }> Výstup
A B C D>
Složitost výše uvedené metody:
Časová náročnost: O(n), kde „n“ je velikost seznamu.
Pomocný prostor: O(1), Konstantní prostor se používá pro proměnné smyčky (v tomto případě i).panda tát
Metody 6: Použití Spliteratoru (Java 8 a novější)
Java 8 představila Spliterátor rozhraní, což je zkratka pro split iterator. Poskytuje způsob, jak iterovat prvky způsobem, který je šetrnější k paralelám. Spliterator lze získat z různých zdrojů, včetně sbírek, jako jsou seznamy. Metoda forEachRemaining Spliteratoru se používá k postupnému procházení všech zbývajících prvků.
Syntax:
Spliterator spliterator = myList.spliterator();>
Níže je uveden příklad této metody:
Jáva // 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'); // Použití Spliterator Spliteratorspliterator = myList.spliterator(); spliterator.forEachRemaining(System.out::println); } }> Výstup
A B C D>
Složitost výše uvedené metody:
Časová náročnost: O(n), kde „n“ je velikost seznamu.
Pomocný prostor: O(log n) nebo O(1), (v závislosti na vlastnostech implementace Spliteratoru)