Java中迭代列表的方法

作为Java语言的新手，我正在尝试熟悉遍历列表（或者其他集合）的所有方法（或者至少是非病态的方法），以及每种方法的优缺点

给定一个

List

对象，我知道通过以下方法循环所有元素：

基本（当然，还有等价的

while

/

do while

循环） , ... （来自Java8流API的映射方法（参见@i_am_zero的答案）

在实现

Iterable

（例如，所有

List

s）的Java8集合类中，现在有了一个

forEach

方法，可以使用该方法代替上面演示的方法。（这是一个很好的比较。）

如果有的话，还有什么其他的方法

---

（顺便说一句，我的兴趣根本不是出于对的渴望；我只是想知道作为一名开发人员，我可以使用哪些表单。）

您可以通过while循环和更多的代码来切换第一个和第三个示例。这使您能够在以下情况下使用do：

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

inti=0；
做{
E元素=list.get（i）；
i++；
}
而（i

---

当然，如果list.size（）返回0，这种情况可能会导致NullPointerException，因为它总是至少执行一次。这可以通过在使用元素的属性/方法tho之前测试元素是否为null来解决。尽管如此，使用循环for

是非常简单和容易的，但我不知道你认为什么是病态的，但是让我提供一些你以前没有见过的替代方案：

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

---

我提到它们是因为您“对Java有些陌生”，这可能会很有趣。

问题中列出的每种示例：

ListIterationExample.java

import java.util.*；
公共类ListIterationExample{
公共静态void main（字符串[]args）{
列表编号=新的ArrayList（）；
//用初始值填充列表
对于（整数i:Arrays.asList（0,1,2,3,4,5,6,7））
增加（i）；
打印列表（数字）；//0,1,2,3,4,5,6,7
//将每个元素替换为其值的两倍
对于（int index=0；index

这三种循环形式几乎相同。增强的

for

循环：

for (E element : list) {
    . . .
}

根据，在效果上与显式使用迭代器和传统的

for

循环相同。在第三种情况下，您只能通过删除当前元素来修改列表内容，并且只有通过迭代器本身的

remove

方法才能修改列表内容。使用基于索引的迭代，您可以以任何方式自由修改列表。但是，添加或删除当前索引之前的元素可能会导致循环跳过元素或多次处理同一元素；进行此类更改时，需要正确调整循环索引

在所有情况下，

元素

都是对实际列表元素的引用。所有迭代方法都不会复制列表中的任何内容。对

元素内部状态的更改将始终显示在列表中相应元素的内部状态中

本质上，只有两种方法可以迭代列表：使用索引或使用迭代器。增强的for循环只是Java5中引入的一种语法快捷方式，以避免显式定义迭代器的繁琐。对于这两种样式，您都可以使用
For
、
while
或
do while
块产生基本上微不足道的变化，但它们都归结为同一件事（或者说，两件事）

编辑：正如@iX3在一篇评论中指出的，您可以在迭代时使用
ListIterator
设置列表的当前元素。您需要使用而不是初始化
for (ListIterator<E> iter = list.listIterator(); iter.hasNext(); ) {
    E element = iter.next();
    // 1 - can call methods of element
    // 2 - can use iter.remove() to remove the current element from the list
    // 3 - can use iter.add(...) to insert a new element into the list
    //     between element and iter->next()
    // 4 - can use iter.set(...) to replace the current element

    // ...
}

list.stream().map(e -> e + 1); // Can apply a transformation function for e

Arrays.asList(1,2,3,4).forEach(System.out::println);
// 1 - can call methods of an element
// 2 - would need reference to containing object to remove an item
//     (TODO: someone please confirm / deny this)
// 3 - functionally separates iteration from the action
//     being performed with each item.

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
// Same capabilities as above plus potentially greater
// utilization of parallelism
// (caution: consequently, order of execution is not guaranteed,
// see [Stream.forEachOrdered][stream-foreach-ordered] for more
// information about this).

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

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

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

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

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());
     }
}

for (E element : list) {
    . . .
}

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));
    }
}

for ( FormalParameter : Expression ) Statement

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

list.get(i)

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

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

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

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

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

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

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);
                }
        );
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class test1 {

public static void main(String[] args) {
    //******* Exercise 1 : Write a Java program to create a new array list, add some colors (string) and print out the collection.
    List<String> colors = new ArrayList<String>();
    colors.add("Black");
    colors.add("Red");
    colors.add("Green");
    colors.add("Blue");
    System.out.println(colors);
    
    
    //******* Exercise 2 : Write a Java program to iterate through all elements in a array list. 
    System.out.println("//******* Exercise 2");
    List<Integer> list2 = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    
    // iteration type 1 : using FOR loop
    System.out.println("// iteration type 1");
    for(Integer nb : list2) {
        System.out.print(nb + ", ");
    }
    System.out.println("\n");
    
    // iteration type 2 : using FOR loop
    System.out.println("// iteration type 2");
    for(int i=0; i < list2.size(); i++) {
        System.out.print(list2.get(i) + ", ");
    }System.out.println("\n");
    
    // iteration type 3  : using Do-While loop
    System.out.println("// iteration type 3");
    int index21 = 0;
    
    do {
        System.out.print(list2.get(index21) + ", ");
        index21++;
    }while(index21<list2.size());
    System.out.println("\n");
    
    
    // iteration type 4  : using While loop
    System.out.println("// iteration type 4");
    int index22 = 0;
    while(index22<list2.size()) {
        System.out.print(list2.get(index22) + ", ");
        index22++;
    }

    System.out.println("\n");
    
    
    // iteration type 5  : using  Iterable forEach loop 
    System.out.println("// iteration type 5");
     list2.forEach(elt -> {
         System.out.print(elt + ", ");
     });

    System.out.println("\n");
    
    
    // iteration type 6  : using  Iterator
    System.out.println("// iteration type 6");
    Iterator<Integer> listIterator = list2.iterator();
    while(listIterator.hasNext()) {
        System.out.print( listIterator.next() + ", ");
    }
    
    System.out.println("\n");
    
    // iteration type 7  : using  Iterator (From the beginning)
    System.out.println("// iteration type 7");
    ListIterator<Integer> listIterator21 = list2.listIterator(list2.size());
    while(listIterator21.hasPrevious()) {
        System.out.print( listIterator21.previous() + ", ");
    }

    System.out.println("\n");   
    
    // iteration type 8  : using  Iterator (From the End)
    System.out.println("// iteration type 8");
    ListIterator<Integer> listIterator22 = list2.listIterator();
    while(listIterator22.hasNext()) {
        System.out.print( listIterator22.next() + ", ");
    }

    System.out.println("\n");   
}

}