Java遍历集合

Dear 丶 2022-12-29 02:17 256阅读 0赞

# 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][https_www.jb51.net_article_199102.htm]

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

[https_www.jb51.net_article_199102.htm]: https://www.jb51.net/article/199102.htm