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);

             }

         });