集合的几种遍历方式+中间处理

注意: Arrays.asList()方法创建的列表的大小是固定的,因此我们不能使用add或remove方法
更改列表的大小。否则将抛出UnsupportedOperationException异常。要想能够添加删除元素，需要使用的是ArrayList(或其他可变列表类型)。

1. 使用基本的 for 循环
这也是最简单，最基础的遍历方式。不过该方式需要知道集合的长度，不适合所有集合

List<String> list = Arrays.asList("hangge","google","baidu");
for (int i = 0; i < list.size(); i++){
       System.out.println(list.get(i);
 }

2. 使用迭代器遍历

List<String> list = Arrays.asList("hangge", "google"，"baidu");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
String element = iterator.next();
System. out.println(element);
}

迭代器遍历时可以使用一些方法对集合中的数据进行处理，例如：

//注意，如果你使用的是迭代器遍历，那么要使用iterator.remove方法而不是集合对象的remove方法
//因为会打断迭代器的遍历
List<String> list = Arrays.asList("hangge", "google"，"baidu");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
   string s = iterator. next();
   if (s.equals( "google")) {
          iterator.remove();
    }
}

3. for-each遍历

List<String> list = Arrays.asList( "hangge", "google"，"baidu" );
for (String s : list) {
  system.out.println(s);
}

for-each 循环本质上是使用了迭代器模式，它将迭代器的实现细节隐藏在了语法层面。当使用 for-each循环遍历集合时，编译器会将其转换为使用迭代器的方式。比如上面代码会被编译器转换为类似于以下代码，在底层实现上，for-each循环和使用lterator的方式是等价的:

List<String> list = Arrays.asList("hangge", "google"， "baidu");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
   string s = iterator. next();
   System.out.println(s);
}

注意：使用for-each遍历集合时，只可以改变集合内对象的值，不能添加或者删除对象，Iterator迭代器遍历集合时，如果发生修改操作，应当如何应对？

• fail-fast：
  一旦发现遍历的同时其他人来修改，则立刻抛出异常 ConcurrentModificationException
  ArrayList和Vector使用的就是fail-fast，遍历的同时不能修改，尽快失败
  源码解释：

增强for循环会先创建一个迭代器对象，这个迭代器有一个成员变量expectedModCount（用于记录迭代过程的修改次数），modCount（用于记录list修改的次数），接着调用hasNext方法检查是否有下一个元素，再调用next（）方法移动下一位，每次在调用next方法会先检查修改次数是否发生变化（判断list的修改次数和迭代时修改的次数是否相等）

• fail-safe：
  牺牲一致性来让整个遍历运行完成 遍历时并不会发现新加入的元素，只有重新打印才能发现新的元素， CopyOnWriteArrayList使用的是fail-safe，遍历的同时可以修改，实现读写分离，只不过读的还是原来的数据
  源码解释：

创建迭代器，这个迭代器会把当前数组元素保存下来，该集合每次添加时都会创建复制出新的数组，而迭代器使用的还是原来数组的元素，因此在进行迭代时，依旧变量的是原来的元素

4. 使用Java 8的forEach方法遍历
从Java 8开始，我们可以使用forEach()方法来迭代列表的元素，这个方法在lterable 接口中定义。下面是一个简单样例:
注意:虽然forEach方法可以很方便地遍历任何实现了lterable 接口的集合(它本身就是基于lterator实现的)，但是它并不能用来遍历数组。

List<String> list = Arrays.asList( "hangge", "google", "baidu");
list.forEach(element -> {system.out.println(element);});

该方式还可以配合方法引用来使用，下面代码效果通上面一样:

List<String> list = Arrays.asList("hangge","google"，"baidu");
list.forEach(System.out::println);

5. 使用Stream API的forEach方法遍历
(1）使用Stream API可以很方便地对集合进行各种操作，下面是一个简单的样例:

List<String> list = Arrays.asList("hangge","google"，"baidu");
list.stream( ).forEach(element -> {system.out.println(element);});

(2）该方式同样可以配合方法引用来使用，下面代码效果通上面一样:

List<String> list = Arrays.asList("hangge", "google"，"baidu");
list.stream().forEach(System.out::println);

(3)Stream APl的 forEach方法出了可以遍历集合的，还可以用来遍历任何支持流的对象，包括集合、数组、文件、函数生成器等。

string[ ] array = { "hangge", "google","baidu"};
Arrays.stream(array).forEach(element -> {System.out.println(element);});

6. 使用Listlterator 接口遍历集合(支持前后遍历）
(1) Listerator是lterator接口的子接口。Listerator可以向前或向后遍历列表中的元素，并允许在列表中插入和替换元素。下面是一个简单的样例，可以看到向后遍历和 Iterator用法是一样的:

List<string> list = Arrays.asList("hangge","google","baidu");
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()){
  String name = iterator.next();
  System.out.println(name);
}

(2）我们还可以使用Listlterator向前遍历List中的元素:
注意:要向前遍历的话需要创建了一个从列表末尾开始的Listlterator。

List<String> list = Arrays.asList( "hangge"，"google","baidu");
//创建了一个从列表末尾开始的ListIterator
ListIterator<String> iterator = list.listIterator(list.size());
while (iterator.hasPrevious()){
    String name = iterator.previous();
    System.out.println(name);
}

(3)我们还可以使用Listerator来修改、添加或删除集合中的元素，比如下面样例我们将hangge修改为 hangge.com，在baidu之后添加了一个新元素apple，并删除了所有其他元素。

//创建一个可变列表类型
List<String> list = new ArrayList<>(Arrays.asList( "hangge","google","baidu"));
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
  String name = iterator.next();
  if (name.equals( "hangge")) {
       iterator.set("hangge.com"); //修改元素
  }else if (name.equals( "baidu")) {
       iterator.add( "apple");     //在baidu之后添加元素
  }else {
       iterator.remove();         //删除元素
       }
}
system.out.println(list);

7. 使用并行流遍历
(1）并行流使用多个线程来并行处理集合中的元素，可以提高处理速度。上面的代码使用了并行流来遍历集合list中的元素，并将它们打印出来。

(1)具体有多少个线程同时遍历列表取决于你的系统和JVM的设置。Java8中的并行流使用了ForkJoin框架来实现多线程并行处理。ForkJoin框架会自动根据系统的资源情况决定使用多少个线程来执行任务。
(2)）我们可以使用ForkJoinPool.commonPoo)方法获取系统的公共ForkJoin池，并使用getParalleism方法获取池中的线程数。下面可以查看有多少个线程可用来执行并行流的任务了。

• int parallelism = ForkJoinPool.commonPool().getParallelism();

(3〉我们可以通过指定系统属性java.utl.concurent.ForkJoinPool.common.parallelism
来控制系统的公共ForkJoin池中线程的数量。例如，你可以在启动JVM时指定这个系统属性，比如下面命令会启动4个线程来执行并行流的任务:

• java -Djava.util.concurrent.ForkJoinPool.common.parallelism=4 Hangge

List<Integer> list = Arrays.asList(1，2，3，4，5);
//创建一个并行流（将parallel标志指定为true表示创建并行流)
Stream<Integer> parallelstream = list.parallelstream();//查看流是否支持并行遍历
system.out.println("流是否支持并行遍历:" + parallelStream.isParallel());
//使用forEach()方法遍历并行流
parallelstream.forEach(element -> {System.out.println(element);});

(2）运行结果如下，由于使用了多个线程同时遍历列表中的元素，输出结果可能是乱序的。
注意:使用并行流时，你需要注意线程安全问题。如果你的代码中存在竞争条件或共享可变数据，那么可能会导致程序出现错误。因此，使用并行流时，应该避免共享可变数据，或者使用同步机制来保证线程安全。