5-集合的遍历
# 一.Set集合遍历
# 1.迭代器遍历
// 1. 迭代器遍历
public static void getSet1(Set<String> set) {
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
String value = iterator.next();
System.out.print(value + " ");
}
}
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
# 2.增强for
// 2. for-each
public static void getSet2(Set<String> set) {
for (String s : set) {
System.out.print(s + " ");
}
}
1
2
3
4
5
6
2
3
4
5
6
# 3. Collection中的toArray()方法遍历
// 3. 使用Collection中的toArray()方法遍历
public static void getSet3(Set<String> set) {
Object[] objs = set.toArray();
for (int i = 0; i < objs.length; i++) {
System.out.print(objs[i] + " ");
}
}
1
2
3
4
5
6
7
2
3
4
5
6
7
# 4.Lambda表达式
同理相同的代码可以遍历List集合
遍历Set集合
// 4.使用Collection中的toArray(T[] t)方法遍历
public static void getSet4(Set<String> set) {
set.forEach(n -> System.out.println(n));
set.forEach(System.out::println);
}
1
2
3
4
5
2
3
4
5
遍历List集合
list.forEach(n -> System.out.println(n));
System.out.println("=====4.使用lambda表达式遍历List集合=====");
list.forEach(System.out::println);
1
2
3
4
5
2
3
4
5
# 二.Map集合遍历
🔉Map集合是我们几乎每天都要使用的集合类,但是其无法像数组那样直接遍历,而是通过迭代器来遍历。以下列举五种遍历方式,推荐使用第一种。
# 1. EntrySet
entrySet是 key-value
的集合,Set里面的类型是Map.Entry,就是存放Map中的某一对key-value,一般可以通过map.entrySet()得到。
entrySet实现了Set接口,里面存放的是键值对。一个K对应一个V。
即通过
getKey()
得到K,getValue()
得到V
for-each 和 迭代器两种遍历
/**
* 【EntrySet】
* 通过Map.Entry(String,String)来映射结果集
* - 然后使用entry.getKey()获取到键
* - 通过entry.getValue()获取到值
*/
@Test
public void test1() {
Map<String, String> map = new HashMap<>();
map.put("张三", "内蒙古");
map.put("李四", "北京");
map.put("王五", "上海");
map.put("赵六", "杭州");
map.put("田七", "南京");
//增强for遍历
//entry.getKey()获取到键,通过entry.getValue()获取到值
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key:" + entry.getKey() + " value:" + entry.getValue());
}
System.out.println("========================分割线==============================");
//迭代器遍历
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());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 2. keySet获取key结果集
通过map.keySet()
获取key的结果集,Set里面的类型即key的类型
- 通过key找到value
for-each 和 迭代器两种遍历
/**
* 【KeySet】: 将HashMap中的key取出放入到Set集合中,根据key映射value
* - 通过map.keySet()获取key
* - 通过key找到value
*/
@Test
public void test2() {
Map<String, String> map = new HashMap<>();
map.put("张三", "内蒙古");
map.put("李四", "北京");
map.put("王五", "上海");
map.put("赵六", "杭州");
map.put("田七", "南京");
//通过map.keySet()获取key, 通过key找到value
for (String key : map.keySet()) {
String value = map.get(key);
System.out.println("key:" + key + " value:" + value);
}
System.out.println("========================分割线==============================");
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
String key = iterator.next();
System.out.println(key);
System.out.println(map.get(key));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 3. Lambda-forEach
通过Map.Entry(String,String)
来映射结果集,然后使用entry.getKey()
获取到键,通过entry.getValue()获取到值
/**
* 【Lambda】
* JDLK8 后Map默认的迭代
*/
@Test
public void test3() {
Map<String, String> map = new HashMap<>();
map.put("张三", "内蒙古");
map.put("李四", "北京");
map.put("王五", "上海");
map.put("赵六", "杭州");
map.put("田七", "南京");
// key-value的类型省略
map.forEach((key, value) -> {
System.out.println("key:" + key + " value:" + value);
});
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 4. Stream-forEach
/**
* 【Streams API 单线程】
*/
@Test
public void test4() {
Map<String, String> map = new HashMap<>();
map.put("张三", "内蒙古");
map.put("李四", "北京");
map.put("王五", "上海");
map.put("赵六", "杭州");
map.put("田七", "南京");
map.put("贾七", "南京");
// 遍历
map.entrySet().stream().forEach((entry) -> {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
});
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 5. key和value分开遍历
Set集合分别获取key与value -- key不能重复, key-value顺序不对应
- 遍历map的键
- 获取map的值的集合 [map.values ->返回 Collections]
/**
* 【Set集合分别获取key与value -- key不能重复, key-value顺序不对应】
* - 遍历map的键[]
* - 遍历map的值
*/
@Test
public void test5() {
Map<String, String> map = new HashMap<>();
map.put("张三", "内蒙古");
map.put("李四", "北京");
map.put("王五", "上海");
map.put("赵六", "杭州");
map.put("田七", "南京");
map.put("郑八", "南京");
//第三种只遍历键或者值,通过加强for循环
//遍历map的键
for (String key : map.keySet()) {
System.out.println("key: " + key);
}
//获取到 map的value集合
Collection<String> values = map.values();
for (String value : map.values()) {
System.out.println("value: " + value);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
计算一个字符串中每个字符出现次数
解题思路:
使用 Scanner获取用户输入的字符串
创建Map集合,key是字符串中的字符, value是字符的个数
遍历字符串获取每一个字符
使用获取到的字符,去Map集合判断key是否存在
key存在:
通过字符(key),获取vaue(字符个数)
value++
put(key, value)把新的 value存储到Map集合中
key不存在:
- put(key, 1)
遍历Map集合,输出结果
编辑 (opens new window)
上次更新: 2021/06/27, 10:49:09