Java实现List，Map，Set 遍历的多种方式

一、简介

  我们在日常的学习和工作中，经常会遇到要遍历一些对象，这些对象可能是List、Map、Set等，今天就稍微列举几个它们常用的遍历方式，让大家也可以选取合适的遍历方式。先声明下，我这里的JDK环境是JDK8（担心有些小伙伴还是1.6，有些方法运行不了）。

普通for循环、增强for循环（foreach）、迭代器（iterator）、forEach

二、List的遍历方式

2.1、List常见初始化

  一般是

List<String> list = Arrays.asList("apple", "banana", "pear", "orange", "strawberry");
1

  或者

List<String> list = new ArrayList<>();
list.add("apple");// 苹果
list.add("banana");// 香蕉
list.add("pear");// 梨
list.add("orange");// 橘子
list.add("strawberry");// 草莓
1
2
3
4
5
6

  或者

List<String> stringList = new ArrayList<String>(){{
   add("apple");// 苹果
   add("banana");// 香蕉
   add("pear");// 梨
   add("orange");// 橘子
   add("strawberry");// 草莓
}};
1
2
3
4
5
6
7

2.2、普通for循环

public static void methodOne(List<String> list) {
    // 最常见的for循环，拿到数组的长度就可以遍历，还能得到元素的索引
    for (int i = 0, len = list.size(); i < len; i++) {
        String value = list.get(i);
        log.info("for循环遍历方式得到元素【{}】，它的索引为【{}】", value, i);
    }
}
1
2
3
4
5
6
7

2.3、增强for循环（推荐）

public static void methodTwo(List<String> list) {
    // 增强for循环遍历，非常的方便，但是没法直接拿到元素的准确的索引，因为list的indexOf()方法如果遇到重复元素就不准确了
    for (String fruit : list) {
        log.info("增强for循环遍历方式得到元素【{}】", fruit);
    }
}
1
2
3
4
5
6

2.4、集合类通用遍历

public static void methodThree(List<String> list) {
    // 集合类通用遍历
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        String value = iterator.next();
        log.info("集合类通用遍历方式得到元素【{}】", value);
    }
}
1
2
3
4
5
6
7
8

2.5、lambda表达式forEach方法

public static void methodFour(List<String> list) {
    // 通过lambda表达式forEach方法遍历
    list.forEach(value -> log.info("数组的foreach方法遍历得到元素【{}】", value));
}
1
2
3
4

2.6、Java8中stream流

public static void methodFive(List<String> list) {
    // Java8中stream流处理完后使用forEach方法
    list.stream().map(String::toUpperCase).forEach(value -> log.info("Java8中stream流处理完后遍历得到元素【{}】", value));
}
1
2
3
4

  如果我们的结果还需要进行处理的话（比如过滤，集合，分组，统计等），我建议还是使用Java8的stream流，非常的简洁和方便。

2.7、统一测试

  我这里就不分开写了，五个方法一起测试了，具体结果大家也可以看看。

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("apple");// 苹果
    list.add("banana");// 香蕉
    list.add("pear");// 梨
    list.add("orange");// 橘子
    list.add("strawberry");// 草莓
    // 调用(这只是演示，方法没有考虑null问题，实际根据需要处理)
    log.info("-------------------------List遍历->调用methodOne方法-------------------------------");
    methodOne(list);
    log.info("-------------------------List遍历->调用methodTwo方法（【推荐】）-------------------------------");
    methodTwo(list);
    log.info("-------------------------List遍历->调用methodThree方法-------------------------------");
    methodThree(list);
    log.info("-------------------------List遍历->调用methodFour方法-------------------------------");
    methodFour(list);
    log.info("-------------------------List遍历->调用methodFive方法-------------------------------");
    methodFive(list);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果：

-------------------------List遍历->调用methodOne方法-------------------------------
for循环遍历方式得到元素【apple】，它的索引为【0】
for循环遍历方式得到元素【banana】，它的索引为【1】
for循环遍历方式得到元素【pear】，它的索引为【2】
for循环遍历方式得到元素【orange】，它的索引为【3】
for循环遍历方式得到元素【strawberry】，它的索引为【4】
-------------------------List遍历->调用methodTwo方法（【推荐】）-------------------------------
增强for循环遍历方式得到元素【apple】
增强for循环遍历方式得到元素【banana】
增强for循环遍历方式得到元素【pear】
增强for循环遍历方式得到元素【orange】
增强for循环遍历方式得到元素【strawberry】
-------------------------List遍历->调用methodThree方法-------------------------------
集合类通用遍历方式得到元素【apple】
集合类通用遍历方式得到元素【banana】
集合类通用遍历方式得到元素【pear】
集合类通用遍历方式得到元素【orange】
集合类通用遍历方式得到元素【strawberry】
-------------------------List遍历->调用methodFour方法-------------------------------
数组的foreach方法遍历得到元素【apple】
数组的foreach方法遍历得到元素【banana】
数组的foreach方法遍历得到元素【pear】
数组的foreach方法遍历得到元素【orange】
数组的foreach方法遍历得到元素【strawberry】
-------------------------List遍历->调用methodFive方法-------------------------------
Java8中stream流处理完后遍历得到元素【APPLE】
Java8中stream流处理完后遍历得到元素【BANANA】
Java8中stream流处理完后遍历得到元素【PEAR】
Java8中stream流处理完后遍历得到元素【ORANGE】
Java8中stream流处理完后遍历得到元素【STRAWBERRY】
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

三、Map的遍历方式

3.1、Map常见初始化

  一般是

Map<String, String> map = new HashMap<>();
map.put("apple", "苹果");
map.put("banana", "香蕉");
map.put("pear", "梨子");
map.put("orange", "橘子");
map.put("strawberry", "草莓");
1
2
3
4
5
6

  或者

Map<String, String> map = new HashMap<String, String>(){{
     put("apple", "苹果");
     put("banana", "香蕉");
     put("pear", "梨子");
     put("orange", "橘子");
     put("strawberry", "草莓");
}};
1
2
3
4
5
6
7

3.2、entrySet + ForEach（推荐）

public static void methodOne(Map<String, String> map) {
    // 通过entrySet()得到Set集合，然后使用ForEach遍历
    Set<Map.Entry<String, String>> entries = map.entrySet();
    for (Map.Entry<String, String> entry : entries) {
        String key = entry.getKey();
        String value = entry.getValue();
        log.info("通过entrySet()得到Set集合，然后使用ForEach遍历map得到的结果：key-->{}，value-->{}", key, value);
    }
}
1
2
3
4
5
6
7
8
9

3.3、entrySet +迭代器

public static void methodTwo(Map<String, String> map) {
    // 通过entrySet()得到Set集合，然后使用迭代器遍历
    Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry<String, String> entry = iterator.next();
        String key = entry.getKey();
        String value = entry.getValue();
        log.info("通过通用迭代器遍历map-->得到的结果：key-->{}，value-->{}", key, value);
    }
}
1
2
3
4
5
6
7
8
9
10

3.4、keySet + 增强for循环

public static void methodThree(Map<String, String> map) {
    // 通过keySet()得到key集合，然后使用ForEach遍历key
    Set<String> keySets = map.keySet();
    for (String key : keySets) {
        String value = map.get(key);
        log.info("通过keySet()得到key集合（ForEach遍历），得到的结果：key-->{}，value-->{}", key, value);
    }
}
1
2
3
4
5
6
7
8

3.5、keySet + 迭代器

public static void methodFour(Map<String, String> map) {
    // 通过keySet()得到key集合，然后使用迭代器遍历
    Iterator<String> iterator = map.keySet().iterator();
    while (iterator.hasNext()) {
        String key = iterator.next();
        String value = map.get(key);
        log.info("通过keySet()得到迭代集合（迭代器遍历），得到的结果：key-->{}，value-->{}", key, value);
    }
}
1
2
3
4
5
6
7
8
9

3.6、lambda表达式forEach方法

public static void methodFive(Map<String, String> map) {
    // 通过lambda表达式forEach方法
    map.forEach((key, value) -> log.info("通过map的forEach()遍历map得到的结果：key-->{}，value-->{}", key, value));
}
1
2
3
4

3.7、Java8流的forEach遍历（推荐）

public static void methodSix(Map<String, String> map) {
    // 通过Java8流的forEach遍历
    map.entrySet().stream().forEach((entry) -> {
        String key = entry.getKey();
        String value = entry.getValue();
        log.info("通过Java8流遍历map得到的结果：key-->{}，value-->{}", key, value);
    });
}
1
2
3
4
5
6
7
8

3.8 、统一测试

public static void main(String[] args) {
    Map<String, String> map = new HashMap<>();
    map.put("apple", "苹果");
    map.put("banana", "香蕉");
    map.put("pear", "梨子");
    map.put("orange", "橘子");
    map.put("strawberry", "草莓");
    // 调用(这只是演示，方法没有考虑null问题，实际根据需要处理)
    log.info("-------------------------Map遍历-->调用methodOne方法（【推荐】）-------------------------------");
    methodOne(map);
    log.info("-------------------------Map遍历-->调用methodTwo方法-------------------------------");
    methodTwo(map);
    log.info("-------------------------Map遍历-->调用methodThree方法-------------------------------");
    methodThree(map);
    log.info("-------------------------Map遍历-->调用methodFour方法-------------------------------");
    methodFour(map);
    log.info("-------------------------Map遍历-->调用methodFive方法-------------------------------");
    methodFive(map);
    log.info("-------------------------Map遍历-->调用methodSix方法（【推荐】）-------------------------------");
    methodSix(map);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：

-------------------------Map遍历-->调用methodOne方法（【推荐】）-------------------------------
通过entrySet()得到Set集合，然后使用ForEach遍历map得到的结果：key-->banana，value-->香蕉
通过entrySet()得到Set集合，然后使用ForEach遍历map得到的结果：key-->orange，value-->橘子
通过entrySet()得到Set集合，然后使用ForEach遍历map得到的结果：key-->apple，value-->苹果
通过entrySet()得到Set集合，然后使用ForEach遍历map得到的结果：key-->pear，value-->梨子
通过entrySet()得到Set集合，然后使用ForEach遍历map得到的结果：key-->strawberry，value-->草莓
-------------------------Map遍历-->调用methodTwo方法-------------------------------
通过通用迭代器遍历map-->得到的结果：key-->banana，value-->香蕉
通过通用迭代器遍历map-->得到的结果：key-->orange，value-->橘子
通过通用迭代器遍历map-->得到的结果：key-->apple，value-->苹果
通过通用迭代器遍历map-->得到的结果：key-->pear，value-->梨子
通过通用迭代器遍历map-->得到的结果：key-->strawberry，value-->草莓
-------------------------Map遍历-->调用methodThree方法-------------------------------
通过keySet()得到key集合（ForEach遍历），得到的结果：key-->banana，value-->香蕉
通过keySet()得到key集合（ForEach遍历），得到的结果：key-->orange，value-->橘子
通过keySet()得到key集合（ForEach遍历），得到的结果：key-->apple，value-->苹果
通过keySet()得到key集合（ForEach遍历），得到的结果：key-->pear，value-->梨子
通过keySet()得到key集合（ForEach遍历），得到的结果：key-->strawberry，value-->草莓
-------------------------Map遍历-->调用methodFour方法-------------------------------
通过keySet()得到迭代集合（迭代器遍历），得到的结果：key-->banana，value-->香蕉
通过keySet()得到迭代集合（迭代器遍历），得到的结果：key-->orange，value-->橘子
通过keySet()得到迭代集合（迭代器遍历），得到的结果：key-->apple，value-->苹果
通过keySet()得到迭代集合（迭代器遍历），得到的结果：key-->pear，value-->梨子
通过keySet()得到迭代集合（迭代器遍历），得到的结果：key-->strawberry，value-->草莓
-------------------------Map遍历-->调用methodFive方法-------------------------------
通过map的forEach()遍历map得到的结果：key-->banana，value-->香蕉
通过map的forEach()遍历map得到的结果：key-->orange，value-->橘子
通过map的forEach()遍历map得到的结果：key-->apple，value-->苹果
通过map的forEach()遍历map得到的结果：key-->pear，value-->梨子
通过map的forEach()遍历map得到的结果：key-->strawberry，value-->草莓
-------------------------Map遍历-->调用methodSix方法（【推荐】）-------------------------------
通过Java8流遍历map得到的结果：key-->banana，value-->香蕉
通过Java8流遍历map得到的结果：key-->orange，value-->橘子
通过Java8流遍历map得到的结果：key-->apple，value-->苹果
通过Java8流遍历map得到的结果：key-->pear，value-->梨子
通过Java8流遍历map得到的结果：key-->strawberry，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
29
30
31
32
33
34
35
36

四、Set的遍历方式

4.1、Set常见初始化

  一般是

Set<String> set = new HashSet<>();
set.add("apple");// 苹果
set.add("banana");// 香蕉
set.add("pear");// 梨
set.add("orange");// 橘子
set.add("strawberry");// 草莓
1
2
3
4
5
6

  或者

Set<String> set = new HashSet<String>(){{
    add("apple");// 苹果
    add("banana");// 香蕉
    add("pear");// 梨
    add("orange");// 橘子
    add("strawberry");// 草莓
}};
1
2
3
4
5
6
7

4.2、通过增强for循环（推荐）

public static void methodOne(Set<String> set) {
    // 通过增强for循环遍历
    for (String value : set) {
        log.info("通过foreach遍历得到结果：{}", value);
    }
}
1
2
3
4
5
6

4.3、通用迭代器遍历

public static void methodTwo(Set<String> set) {
    // 通用迭代器遍历
    Iterator<String> iterator = set.iterator();
    while (iterator.hasNext()) {
        String value = iterator.next();
        log.info("通用迭代器遍历得到结果：{}", value);
    }
}
1
2
3
4
5
6
7
8

4.4、lambda表达式forEach方法

public static void methodThree(Set<String> set) {
    // 通过lambda表达式forEach方法遍历
    set.forEach(value -> log.info("通过lambda表达式forEach方法遍历得到结果：{}", value));
}
1
2
3
4

4.5、Java8流的foreach方法

public static void methodFour(Set<String> set) {
    // 通过Java8流的foreach方法遍历
    set.stream().forEach(value -> {
        log.info("通过Java8流的foreach方法遍历得到结果：{}", value);
    });
}
1
2
3
4
5
6

4.6、转数组再for循环

public static void methodFive(Set<String> set) {
    // 转数组再for循环遍历
    int size = set.size();
    String[] strArray = new String[size];
    // 一定要注意的是strArray的类型要和set的类型一致（集合的类型是什么，数组的类型就要是什么）
    String[] strings = set.toArray(strArray);
    for (String value : strings) {
        log.info("通过转数组再for循环遍历得到结果：{}", value);
    }
}
1
2
3
4
5
6
7
8
9
10

4.7、统一测试

public static void main(String[] args) {
    Set<String> set = new HashSet<>();
    set.add("apple");// 苹果
    set.add("banana");// 香蕉
    set.add("pear");// 梨
    set.add("orange");// 橘子
    set.add("strawberry");// 草莓
    // 调用(这只是演示，方法没有考虑null问题，实际根据需要处理)
    log.info("-------------------------Set遍历->调用methodOne方法【推荐】-------------------------------");
    methodOne(set);
    log.info("-------------------------Set遍历->调用methodTwo方法-------------------------------");
    methodTwo(set);
    log.info("-------------------------Set遍历->调用methodThree方法-------------------------------");
    methodThree(set);
    log.info("-------------------------Set遍历->调用methodFour方法-------------------------------");
    methodFour(set);
    log.info("-------------------------Set遍历->调用methodFive方法-------------------------------");
    methodFive(set);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果：

-------------------------Set遍历->调用methodOne方法【推荐】-------------------------------
通过foreach遍历得到结果：banana
通过foreach遍历得到结果：orange
通过foreach遍历得到结果：apple
通过foreach遍历得到结果：pear
通过foreach遍历得到结果：strawberry
-------------------------Set遍历->调用methodTwo方法-------------------------------
通用迭代器遍历得到结果：banana
通用迭代器遍历得到结果：orange
通用迭代器遍历得到结果：apple
通用迭代器遍历得到结果：pear
通用迭代器遍历得到结果：strawberry
-------------------------Set遍历->调用methodThree方法-------------------------------
通过lambda表达式forEach方法遍历得到结果：banana
通过lambda表达式forEach方法遍历得到结果：orange
通过lambda表达式forEach方法遍历得到结果：apple
通过lambda表达式forEach方法遍历得到结果：pear
通过lambda表达式forEach方法遍历得到结果：strawberry
-------------------------Set遍历->调用methodFour方法-------------------------------
通过Java8流的foreach方法遍历得到结果：banana
通过Java8流的foreach方法遍历得到结果：orange
通过Java8流的foreach方法遍历得到结果：apple
通过Java8流的foreach方法遍历得到结果：pear
通过Java8流的foreach方法遍历得到结果：strawberry
-------------------------Set遍历->调用methodFive方法-------------------------------
通过转数组再for循环遍历得到结果：banana
通过转数组再for循环遍历得到结果：orange
通过转数组再for循环遍历得到结果：apple
通过转数组再for循环遍历得到结果：pear
通过转数组再for循环遍历得到结果：strawberry
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