list的遍历方式

梦里梦外; 2023-02-25 03:43 5阅读 0赞

### 遍历方式： ###

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