Java 集合遍历

  1 在集合中使用Lambda表达式
  2 Map集合中
  3 forEach and Map
  4 常规遍历-> 两种遍历：
  5 Map map = new HashMap();
  6         map.put(102, "张三");
  7         map.put(105, "李四");
  8         map.put(109, "王五");
  9         map.put(110, "董六");
 10         map.put(111, "李四");
 11 
 12         // 1.使用for-each循环遍历
 13         System.out.println("--1.使用for-each循环遍历--");
 14         // 获得键集合
 15         Set keys = map.keySet();
 16         for (Object key : keys) {
 17             int ikey = (Integer) key; // 自动拆箱
 18             String value = (String) map.get(ikey); // 自动装箱
 19             System.out.printf("key=%d - value=%s \n", ikey, value);
 20         }
 21 
 22         // 2.使用迭代器遍历
 23         System.out.println("--2.使用迭代器遍历--");
 24         // 获得值集合
 25         Collection values = map.values();
 26         // 遍历值集合
 27         Iterator it = values.iterator();
 28         while (it.hasNext()) {
 29             Object item = it.next();
 30             String s = (String) item;
 31             System.out.println("值集合元素: " + s);
 32         }
 33 
 34 常规遍历对比Lambda遍历
 35 Map<String, Integer> items = new HashMap<>();
 36     items.put("A", 10);
 37     items.put("B", 20);
 38     items.put("C", 30);
 39     items.put("D", 40);
 40     items.put("E", 50);
 41     items.put("F", 60);
 42 
 43     for (Map.Entry<String, Integer> entry : items.entrySet()) {
 44         System.out.println("Item : " + entry.getKey() + " Count : " + entry.getValue());
 45     }
 46 
 47 Lambda遍历
 48 Map<String, Integer> items = new HashMap<>();
 49     items.put("A", 10);
 50     items.put("B", 20);
 51     items.put("C", 30);
 52     items.put("D", 40);
 53     items.put("E", 50);
 54     items.put("F", 60);
 55 
 56     items.forEach((k,v)->System.out.println("Item : " + k + " Count : " + v));
 57 
 58     items.forEach((k,v)->{
 59         System.out.println("Item : " + k + " Count : " + v);
 60         if("E".equals(k)){
 61             System.out.println("Hello E");
 62         }
 63     });
 64 
 65 List集合中
 66 forEach and List
 67 常规遍历-> 三种遍历：
 68 List list = new ArrayList();
 69         String b = "B";
 70         // 向集合中添加元素
 71         list.add("A");
 72         list.add(b);
 73         list.add("C");
 74         list.add(b);
 75         list.add("D");
 76         list.add("E");
 77 
 78         // 1.使用for循环遍历
 79         System.out.println("--1.使用for循环遍历--");
 80         for (int i = 0; i < list.size(); i++) {
 81             System.out.printf("读取集合元素(%d): %s \n", i, list.get(i));
 82         }
 83 
 84         // 2.使用for-each循环遍历
 85         System.out.println("--2.使用for-each循环遍历--");
 86         for (Object item : list) {
 87             String s = (String) item;
 88             System.out.println("读取集合元素: " + s);
 89         }
 90 
 91         // 3.使用迭代器遍历
 92         System.out.println("--3.使用迭代器遍历--");
 93         Iterator it = list.iterator();
 94         while (it.hasNext()) {
 95             Object item = it.next();
 96             String s = (String) item;
 97             System.out.println("读取集合元素: " + s);
 98         }
 99 
100 常规遍历对比Lambda遍历
101 List<String> items = new ArrayList<>();
102     items.add("A");
103     items.add("B");
104     items.add("C");
105     items.add("D");
106     items.add("E");
107 
108     for(String item : items){
109         System.out.println(item);
110     }
111 
112 Lambda遍历
113 List<String> items = new ArrayList<>();
114     items.add("A");
115     items.add("B");
116     items.add("C");
117     items.add("D");
118     items.add("E");
119 
120     //lambda
121     //Output : A,B,C,D,E
122     items.forEach(item->System.out.println(item));
123 
124     //Output : C
125     items.forEach(item->{
126         if("C".equals(item)){
127             System.out.println(item);
128         }
129     });
130 
131     //method reference
132     //Output : A,B,C,D,E
133     items.forEach(System.out::println);
134 
135     //Stream and filter
136     //Output : B
137     items.stream()
138         .filter(s->s.contains("B"))
139         .forEach(System.out::println);
140 
141 Set集合中
142 forEach and Set
143 常规遍历-> 两种遍历：
144 Set set = new HashSet();
145         String b = "B";
146         // 向集合中添加元素
147         set.add("A");
148         set.add(b);
149         set.add("C");
150         set.add(b);
151         set.add("D");
152         set.add("E");
153 
154         // 1.使用for-each循环遍历
155         System.out.println("--1.使用for-each循环遍历--");
156         for (Object item : set) {
157             String s = (String) item;
158             System.out.println("读取集合元素: " + s);
159         }
160 
161         // 2.使用迭代器遍历
162         System.out.println("--2.使用迭代器遍历--");
163         Iterator it = set.iterator();
164         while (it.hasNext()) {
165             Object item = it.next();
166             String s = (String) item;
167             System.out.println("读取集合元素: " + s);
168         }
169 
170 常规遍历对比Lambda遍历：
171 常规遍历
172 Set<String> sets = new HashSet<>();
173         sets.add("A");
174         sets.add("B");
175         sets.add("C");
176         sets.add("D");
177         sets.add("E");
178         sets.add("EA");
179         //Output: A,EA
180         for (String set : sets) {
181             if (set.contains("A")){
182                 System.out.println(set);
183             }
184         }
185 
186 Lambda遍历
187 Set<String> sets = new HashSet<>();
188         sets.add("A");
189         sets.add("B");
190         sets.add("C");
191         sets.add("D");
192         sets.add("E");
193         sets.add("EA");
194         //Output: A,B,C,D,E,EA
195         sets.forEach(set -> System.out.println(set));
196         //Output: A,B,C,D,E,EA
197         sets.forEach(System.out::println);
198         //Output: A,EA
199         sets.stream()
200                 .filter(s -> s.contains("A"))
201                 .forEach(System.out::println);
202         //Output: Hello:C
203         sets.forEach(set -> {
204             if ("C".equals(set)) {
205                 System.out.println("Hello:" + set);
206             }
207         });