Java遍历集合

Java遍历集合 list，set，map

1.java遍历list

   public static void main(String[] args) {

        //先创建一个list集合，放入三条数据
        List<String> list = new ArrayList<>();
        list.add("xiaoming");
        list.add("xiaohong");
        list.add("xiaozhang");
        //1、普通循环遍历
        System.out.println("1、普通循环遍历");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //2、增强for循环遍历
        System.out.println("2、增强for循环遍历");
        for (String s : list) {
            System.out.println(s);
        }
        //3、迭代器方式
        System.out.println("3、迭代器方式");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //4、lambda方式遍历 jdk1.8新语法
        System.out.println("4、lambda方式遍历");
        list.forEach(System.out::println);
        //等同于
        list.forEach(e-> System.out.println(e));

    }

2.java遍历set

    public static void main(String[] args) {

        //先创建一个set集合，放入三条数据
        Set<String> set = new HashSet<>();
        set.add("xiaoming");
        set.add("xiaohong");
        set.add("xiaozhang");
        //1、增强for循环遍历
        System.out.println("1、增强for循环遍历");
        for (String s : set) {
            System.out.println(s);
        }
        //2、迭代器方式
        System.out.println("2、迭代器方式");
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //3、lambda方式遍历 jdk1.8新语法
        System.out.println("3、lambda方式遍历");
        set.forEach(System.out::println);
 
   }

3.java遍历map

  public static void main(String[] args) {
        //先创建一个map集合，放入三条数据
        Map<String,String> map = new HashMap<>();
        map.put("1","xiaoming");
        map.put("2","xiaohong");
        map.put("3","xiaozhang");

        //1、通过获取所有的key按照key来遍历
        System.out.println("1、通过获取所有的key按照key来遍历");
        for (String key : map.keySet()) {
            String value = map.get(key); //得到每个key多对用value的值
            System.out.println(key+"\t"+value);
        }
        //2、通过Map.entrySet使用iterator遍历key和value
        System.out.println("2、通过Map.entrySet使用iterator遍历key和value");
        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, String> entry = it.next();
            System.out.println("key= " + entry.getKey() + "  value= " + entry.getValue());
        }
        //3、通过Map.entrySet遍历key和value，推荐，尤其是容量大时
        System.out.println("3、通过Map.entrySet遍历key和value");
        for (Map.Entry<String, String> entry : map.entrySet()) {
            //Map.entry<Integer,String> 映射项（键-值对）  有几个方法：用上面的名字entry
            //entry.getKey() ;entry.getValue(); entry.setValue();
            //map.entrySet()  返回此映射中包含的映射关系的 Set视图。
            System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
        }
        //4、通过Map.values()遍历所有的value，但不能遍历key
        System.out.println("4、通过Map.values()遍历所有的value，但不能遍历key");
        for (String v : map.values()) {
            System.out.println("value= " + v);
        }
        //5、lambda方式遍历 jdk1.8新语法
        System.out.println("5、lambda方式遍历");
        map.forEach((k,v)-> System.out.println(k+"\t"+v));
       
    }

数据元素是怎样在内存中存放的？

 主要有2种存储方式：

1、顺序存储，Random Access（Direct Access）：

        这种方式，相邻的数据元素存放于相邻的内存地址中，整块内存地址是连续的。可以根据元素的位置直接计算出内存地址，直接进行读取。读取一个特定位置元素的平均时间复杂度为O(1)。正常来说，只有基于数组实现的集合，才有这种特性。Java中以ArrayList为代表。

2、链式存储，Sequential Access：

        这种方式，每一个数据元素，在内存中都不要求处于相邻的位置，每个数据元素包含它下一个元素的内存地址。不可以根据元素的位置直接计算出内存地址，只能按顺序读取元素。读取一个特定位置元素的平均时间复杂度为O(n)。主要以链表为代表。Java中以LinkedList为代表。

每个遍历方法的实现原理是什么？

1、传统的for循环遍历，基于计数器的：

        遍历者自己在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后，停止。主要就是需要按元素的位置来读取元素。

2、迭代器遍历，Iterator：

        每一个具体实现的数据集合，一般都需要提供相应的Iterator。相比于传统for循环，Iterator取缔了显式的遍历计数器。所以基于顺序存储集合的Iterator可以直接按位置访问数据。而基于链式存储集合的Iterator，正常的实现，都是需要保存当前遍历的位置。然后根据当前位置来向前或者向后移动指针。

3、foreach循环遍历：

        根据反编译的字节码可以发现，foreach内部也是采用了Iterator的方式实现，只不过Java编译器帮我们生成了这些代码。

各遍历方式对于不同的存储方式，性能如何？

1、传统的for循环遍历，基于计数器的：

        因为是基于元素的位置，按位置读取。所以我们可以知道，对于顺序存储，因为读取特定位置元素的平均时间复杂度是O(1)，所以遍历整个集合的平均时间复杂度为O(n)。而对于链式存储，因为读取特定位置元素的平均时间复杂度是O(n)，所以遍历整个集合的平均时间复杂度为O(n2)（n的平方）。

2、迭代器遍历，Iterator：

        那么对于RandomAccess类型的集合来说，没有太多意义，反而因为一些额外的操作，还会增加额外的运行时间。但是对于Sequential Access的集合来说，就有很重大的意义了，因为Iterator内部维护了当前遍历的位置，所以每次遍历，读取下一个位置并不需要从集合的第一个元素开始查找，只要把指针向后移一位就行了，这样一来，遍历整个集合的时间复杂度就降低为O(n)；

3、foreach循环遍历：

        分析Java字节码可知，foreach内部实现原理，也是通过Iterator实现的，只不过这个Iterator是Java编译器帮我们生成的，所以我们不需要再手动去编写。但是因为每次都要做类型转换检查，所以花费的时间比Iterator略长。时间复杂度和Iterator一样。

各遍历方式的适用于什么场合？

1、传统的for循环遍历，基于计数器的：

        顺序存储：读取性能比较高。适用于遍历顺序存储集合。

        链式存储：时间复杂度太大，不适用于遍历链式存储的集合。

2、迭代器遍历，Iterator：

        顺序存储：如果不是太在意时间，推荐选择此方式，毕竟代码更加简洁，也防止了Off-By-One的问题。

        链式存储：意义就重大了，平均时间复杂度降为O(n)，还是挺诱人的，所以推荐此种遍历方式。

3、foreach循环遍历：

        foreach只是让代码更加简洁了，但是他有一些缺点，就是遍历过程中不能操作数据集合（删除等），所以有些场合不使用。而且它本身就是基于Iterator实现的，但是由于类型转换的问题，所以会比直接使用Iterator慢一点，但是还好，时间复杂度都是一样的。所以怎么选择，参考上面两种方式，做一个折中的选择。

关于lambda遍历的性能

参考：https://www.jb51.net/article/199102.htm

结论：对于耗时的操作用lambda表达式的for循环，如数据库的IO操作，多线程充分利用CPU资源；对于不太耗时的操作使用普通for循环，比如纯CPU计算类型的操作，单线程性能更高，减少上下文切换的开销。