list的遍历方式

遍历方式：

lambda、Itrator、ListIterator、Enumeration、foreach

for、foreach、Iteractor三种遍历方式的区别：

1. for比较适合实现可预知大小的集合或数组的遍历
2. foreach该方式适用于Collection的所有子类,适合集合或数组大小未知的情况。foreach需要事先知道集合或数组类型。
3. Iterator该方式适用于Collection的所有子类,适合集合大小未知的情况，不需要事先知道集合类型。(Iterator只能遍历集合)
4. 总之，Iterator相比于for、foreach功能更加强大，他可以随时修改或者删除集合内部的元素，并且是在不需要知道元素和集合的类 型的情况下进行的，当你需要对不同的容器实现同样的遍历方式时，迭代器是最好的选择！

代码块

package com.example.demo.util;

import java.util.*;

public class TraverseList {
    public static void main(String[] args) {
        //1. 初始化list
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //2. 遍历list几种方式
        System.out.println("\n方式一");
        lambda(list);

        System.out.println("\n方式二");
        foreach(list);

        System.out.println("\n方式三");
        forMethod(list);

        System.out.println("\n方式四");
        listIterator(list);

        System.out.println("\n方式五");
        iterator(list);

        System.out.println("\n方式六");
        enumeration();

        //3. 遍历List<Map>
        System.out.println("\n遍历List<Map>");
        listMap();

    }

    /**
     * lambda的循环遍历
     */
    public static void lambda(List<String> list){
        System.out.println("lambda forEach 第一种方式");
        list.stream().forEach(string -> {
            System.out.println(string);
        });

        System.out.println("lambda forEach 第二种方式");
        list.stream().forEach(System.out::println);

        System.out.println("lambda forEach 第三种方式");
        list.forEach((str)-> System.out.print(str+"\t"));

        System.out.println("lambda forEach 第四种方式");
        list.forEach(System.out::println);
    }

    /**
     * foreach 输出
     * 在JDK1.5版本之后开始提供的foreach迭代输出，他支持数组也支持集合输出。
     */
    public static void foreach(List<String> list){
        for (String str:list) {
            System.out.println(str + "\t");
        }
    }

    /**
     * 普通for循环遍历
     */
    public static void forMethod(List<String> list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(i + "\t");
        }
    }

    /**
     * Iterator 迭代输出
     * Iterator是专门的迭代输出接口，迭代输出就是依次判断每个元素，看是否有内容，若有内容则取出。
     */
    public static void iterator(List<String> list){
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next() + "\t");
        }
    }

    /**
     * ListIterator 双向迭代输出
     * ListIterator支持双向迭代输出，可以完成由前向后和由后向前输出。
     */
    public static void listIterator(List<String> list){
        ListIterator<String> listIterator = list.listIterator();
        System.out.println("从头到尾：");
        while(listIterator.hasNext()){
            System.out.println(listIterator.next() + "\t");
        }

        System.out.println("从尾到头：");
        while(listIterator.hasPrevious()){
            System.out.println(listIterator.previous() + "\t");
        }
    }

    /**
     * Enumeration 枚举输出
     * Enumeration是在早期推出的集合输出接口，该接口设置的主要目的是输出Vector集合。在JDK1.5后使用泛型重新进行接口定义。
     */
    public static void enumeration(){
        Vector<String> vector = new Vector<>();
        vector.add("aaa");
        vector.add("bbb");
        vector.add("ccc");

        Enumeration<String> enumeration = vector.elements();
        while(enumeration.hasMoreElements()){
            System.out.println(enumeration.nextElement() + "\t");
        }
    }

    public static void listMap(){
        //1. 初始化List<Map>
        List<Map> list = new ArrayList<>();
        Map<Integer,String> map1 = new HashMap<>();
        map1.put(1,"map1-value1");
        map1.put(2,"map1-value2");
        list.add(map1);
        Map<Integer,String> map2 = new HashMap<>();
        map2.put(1,"map2-value1");
        map2.put(2,"map2-value2");
        list.add(map2);
        Map<Integer,String> map3 = new HashMap<>();
        map3.put(1,"map3-value1");
        map3.put(2,"map3-value2");
        list.add(map3);

        //2. 遍历
        list.forEach(map -> {
            map.forEach((k,v) -> {
                System.out.println("k : " + k + " v : " + v);
            });
        });
    }
}

输出

方式一
lambda forEach 第一种方式
aaa
bbb
ccc
lambda forEach 第二种方式
aaa
bbb
ccc
lambda forEach 第三种方式
aaa	bbb	ccc	lambda forEach 第四种方式
aaa
bbb
ccc

方式二
aaa	
bbb	
ccc	

方式三
0	
1	
2	

方式四
从头到尾：
aaa	
bbb	
ccc	
从尾到头：
ccc	
bbb	
aaa	

方式五
aaa	
bbb	
ccc	

方式六
aaa	
bbb	
ccc	

遍历List<Map>
k : 1 v : map1-value1
k : 2 v : map1-value2
k : 1 v : map2-value1
k : 2 v : map2-value2
k : 1 v : map3-value1
k : 2 v : map3-value2