Java 集合遍历

 在集合中使用Lambda表达式
 Map集合中
 forEach and Map
 常规遍历-> 两种遍历：
 Map map = new HashMap();
         map.put(102, "张三");
         map.put(105, "李四");
         map.put(109, "王五");
         map.put(110, "董六");
         map.put(111, "李四");

         // 1.使用for-each循环遍历
         System.out.println("--1.使用for-each循环遍历--");
         // 获得键集合
         Set keys = map.keySet();
         for (Object key : keys) {
             int ikey = (Integer) key; // 自动拆箱
             String value = (String) map.get(ikey); // 自动装箱
             System.out.printf("key=%d - value=%s \n", ikey, value);
         }

         // 2.使用迭代器遍历
         System.out.println("--2.使用迭代器遍历--");
         // 获得值集合
         Collection values = map.values();
         // 遍历值集合
         Iterator it = values.iterator();
         while (it.hasNext()) {
             Object item = it.next();
             String s = (String) item;
             System.out.println("值集合元素: " + s);
         }

 常规遍历对比Lambda遍历
 Map<String, Integer> items = new HashMap<>();
     items.put("A", 10);
     items.put("B", 20);
     items.put("C", 30);
     items.put("D", 40);
     items.put("E", 50);
     items.put("F", 60);

     for (Map.Entry<String, Integer> entry : items.entrySet()) {
         System.out.println("Item : " + entry.getKey() + " Count : " + entry.getValue());
     }

 Lambda遍历
 Map<String, Integer> items = new HashMap<>();
     items.put("A", 10);
     items.put("B", 20);
     items.put("C", 30);
     items.put("D", 40);
     items.put("E", 50);
     items.put("F", 60);

     items.forEach((k,v)->System.out.println("Item : " + k + " Count : " + v));

     items.forEach((k,v)->{
         System.out.println("Item : " + k + " Count : " + v);
         if("E".equals(k)){
             System.out.println("Hello E");
         }
     });

 List集合中
 forEach and List
 常规遍历-> 三种遍历：
 List list = new ArrayList();
         String b = "B";
         // 向集合中添加元素
         list.add("A");
         list.add(b);
         list.add("C");
         list.add(b);
         list.add("D");
         list.add("E");

         // 1.使用for循环遍历
         System.out.println("--1.使用for循环遍历--");
         for (int i = 0; i < list.size(); i++) {
             System.out.printf("读取集合元素(%d): %s \n", i, list.get(i));
         }

         // 2.使用for-each循环遍历
         System.out.println("--2.使用for-each循环遍历--");
         for (Object item : list) {
             String s = (String) item;
             System.out.println("读取集合元素: " + s);
         }

         // 3.使用迭代器遍历
         System.out.println("--3.使用迭代器遍历--");
         Iterator it = list.iterator();
         while (it.hasNext()) {
             Object item = it.next();
             String s = (String) item;
             System.out.println("读取集合元素: " + s);
         }

 常规遍历对比Lambda遍历
 List<String> items = new ArrayList<>();
     items.add("A");
     items.add("B");
     items.add("C");
     items.add("D");
     items.add("E");

     for(String item : items){
         System.out.println(item);
     }

 Lambda遍历
 List<String> items = new ArrayList<>();
     items.add("A");
     items.add("B");
     items.add("C");
     items.add("D");
     items.add("E");

     //lambda
     //Output : A,B,C,D,E
     items.forEach(item->System.out.println(item));

     //Output : C
     items.forEach(item->{
         if("C".equals(item)){
             System.out.println(item);
         }
     });

     //method reference
     //Output : A,B,C,D,E
     items.forEach(System.out::println);

     //Stream and filter
     //Output : B
     items.stream()
         .filter(s->s.contains("B"))
         .forEach(System.out::println);

 Set集合中
 forEach and Set
 常规遍历-> 两种遍历：
 Set set = new HashSet();
         String b = "B";
         // 向集合中添加元素
         set.add("A");
         set.add(b);
         set.add("C");
         set.add(b);
         set.add("D");
         set.add("E");

         // 1.使用for-each循环遍历
         System.out.println("--1.使用for-each循环遍历--");
         for (Object item : set) {
             String s = (String) item;
             System.out.println("读取集合元素: " + s);
         }

         // 2.使用迭代器遍历
         System.out.println("--2.使用迭代器遍历--");
         Iterator it = set.iterator();
         while (it.hasNext()) {
             Object item = it.next();
             String s = (String) item;
             System.out.println("读取集合元素: " + s);
         }

 常规遍历对比Lambda遍历：
 常规遍历
 Set<String> sets = new HashSet<>();
         sets.add("A");
         sets.add("B");
         sets.add("C");
         sets.add("D");
         sets.add("E");
         sets.add("EA");
         //Output: A,EA
         for (String set : sets) {
             if (set.contains("A")){
                 System.out.println(set);
             }
         }

 Lambda遍历
 Set<String> sets = new HashSet<>();
         sets.add("A");
         sets.add("B");
         sets.add("C");
         sets.add("D");
         sets.add("E");
         sets.add("EA");
         //Output: A,B,C,D,E,EA
         sets.forEach(set -> System.out.println(set));
         //Output: A,B,C,D,E,EA
         sets.forEach(System.out::println);
         //Output: A,EA
         sets.stream()
                 .filter(s -> s.contains("A"))
                 .forEach(System.out::println);
         //Output: Hello:C
         sets.forEach(set -> {
             if ("C".equals(set)) {
                 System.out.println("Hello:" + set);
             }
         });