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.增强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

# 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

# 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

遍历List集合

list.forEach(n -> System.out.println(n));

System.out.println("=====4.使用lambda表达式遍历List集合=====");

list.forEach(System.out::println);

1
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. 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

# 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

# 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

# 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

计算一个字符串中每个字符出现次数

解题思路：

使用 Scanner获取用户输入的字符串
创建Map集合，key是字符串中的字符， value是字符的个数
遍历字符串获取每一个字符
使用获取到的字符，去Map集合判断key是否存在
- key存在：
  - 通过字符（key），获取vaue（字符个数）
  - value++
  - put（key, value）把新的 value存储到Map集合中
- key不存在：
  - put（key, 1）
遍历Map集合，输出结果

编辑

#collection

上次更新: 2021/06/27, 10:49:09

← CopyOnWrite集合 ArrayList→