Sposoby iteracji listy w Javie

Przykład każdego rodzaju wymienionego w pytaniu:

import java.util.*;

public class ListIterationExample {

     public static void main(String []args){
        List<Integer> numbers = new ArrayList<Integer>();

        // populates list with initial values
        for (Integer i : Arrays.asList(0,1,2,3,4,5,6,7))
            numbers.add(i);
        printList(numbers);         // 0,1,2,3,4,5,6,7

        // replaces each element with twice its value
        for (int index=0; index < numbers.size(); index++) {
            numbers.set(index, numbers.get(index)*2); 
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // does nothing because list is not being changed
        for (Integer number : numbers) {
            number++; // number = new Integer(number+1);
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14  

        // same as above -- just different syntax
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            number++;
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // ListIterator<?> provides an "add" method to insert elements
        // between the current element and the cursor
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.add(number+1);     // insert a number right before this
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15

        // Iterator<?> provides a "remove" method to delete elements
        // between the current element and the cursor
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            if (number % 2 == 0)    // if number is even 
                iter.remove();      // remove it from the collection
        }
        printList(numbers);         // 1,3,5,7,9,11,13,15

        // ListIterator<?> provides a "set" method to replace elements
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.set(number/2);     // divide each element by 2
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7
     }

     public static void printList(List<Integer> numbers) {
        StringBuilder sb = new StringBuilder();
        for (Integer number : numbers) {
            sb.append(number);
            sb.append(",");
        }
        sb.deleteCharAt(sb.length()-1); // remove trailing comma
        System.out.println(sb.toString());
     }
}

Pętla podstawowa nie jest zalecana, ponieważ nie znasz implementacji listy.

Jeśli to była LinkedList, każde wywołanie do

list.get(i)

Byłoby iteracją nad listą, co skutkowałoby złożonością czasową N^2.

Iteracja w stylu JDK8:

public class IterationDemo {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        list.stream().forEach(elem -> System.out.println("element " + elem));
    }
}

W Java 8 mamy wiele sposobów iteracji klas kolekcji.

Using Iterable forEach

Zbiory implementujące Iterable (na przykład wszystkie listy) mają teraz metodę forEach. Możemy użyć metody - reference wprowadzonej w Javie 8.

Arrays.asList(1,2,3,4).forEach(System.out::println);

Używanie strumieni forEach i forEachOrdered

Możemy również iterować nad listą używając Stream jako:

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
Arrays.asList(1,2,3,4).stream().forEachOrdered(System.out::println);

Powinniśmy preferować forEachOrdered nad forEach, ponieważ zachowanie forEach jest jawnie nieeterministyczne, gdzie jako forEachOrdered wykonuje akcję dla każdego elementu tego strumienia, w porządku spotkania strumienia, jeśli strumień ma zdefiniowany porządek spotkania. Tak więc forEach nie gwarantuje, że zamówienie zostanie zachowane.

Zaletą strumieni jest to, że możemy również korzystać z równoległych strumieni, gdzie jest to właściwe. Jeśli celem jest tylko wydrukowanie elementów niezależnie od kolejności, możemy użyć parallel stream jako:

Arrays.asList(1,2,3,4).parallelStream().forEach(System.out::println);

Nie wiem, co uważasz za patologiczne, ale pozwól mi podać kilka alternatyw, których wcześniej nie widziałeś: {]}

List<E> sl= list ;
while( ! sl.empty() ) {
    E element= sl.get(0) ;
    .....
    sl= sl.subList(1,sl.size());
}

Lub jego rekurencyjna wersja:

void visit(List<E> list) {
    if( list.isEmpty() ) return;
    E element= list.get(0) ;
    ....
    visit(list.subList(1,list.size()));
}

Również rekurencyjna wersja klasycznego for(int i=0...:

void visit(List<E> list,int pos) {
    if( pos >= list.size() ) return;
    E element= list.get(pos) ;
    ....
    visit(list,pos+1);
}

Wspominam o nich, ponieważ jesteś "trochę nowy w Javie" i to może być interesujące.

Możesz użyć forEach zaczynając od Java 8:

 List<String> nameList   = new ArrayList<>(
            Arrays.asList("USA", "USSR", "UK"));

 nameList.forEach((v) -> System.out.println(v));

Do wyszukiwania wstecz powinieneś użyć następującego:

for (ListIterator<SomeClass> iterator = list.listIterator(list.size()); iterator.hasPrevious();) {
    SomeClass item = iterator.previous();
    ...
    item.remove(); // For instance.
}

Jeśli chcesz poznać pozycję, Użyj iteratora.previousIndex (). Pomaga również napisać wewnętrzną pętlę, która porównuje dwie pozycje na liście (Iteratory nie są sobie równe).

W java 8 możesz użyć metody List.forEach() z lambda expression do iteracji listy.

import java.util.ArrayList;
import java.util.List;

public class TestA {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Apple");
        list.add("Orange");
        list.add("Banana");
        list.forEach(
                (name) -> {
                    System.out.println(name);
                }
        );
    }
}

Prawo, wiele alternatyw są wymienione. Najprostszym i najczystszym byłoby użycie rozszerzonej instrukcji for, Jak Poniżej. {[3] } jest typu iteracyjnego.

for ( FormalParameter : Expression ) Statement

Na przykład, aby iterować, List ids, możemy po prostu tak,

for (String str : ids) {
    // Do something
}

Zawsze możesz wyłączyć pierwszy i trzeci przykład za pomocą pętli while I trochę więcej kodu. Daje to przewagę możliwości użycia Do-while:

int i = 0;
do{
 E element = list.get(i);
 i++;
}
while (i < list.size());

Oczywiście, tego rodzaju rzeczy mogą spowodować wyjątek NullPointerException, jeśli lista.size() zwraca 0, ponieważ zawsze jest wykonywana co najmniej raz. To może być naprawione przez testowanie czy element jest null przed użyciem jego atrybutów / metod tho. Jednak o wiele prostsze i łatwiejsze jest użycie pętli for