Java中，Map、List集合遍历、去重方式超详细总结

Java中常用的遍历方式有：

1. 普通for循环
2. for-each循环
3. 使用迭代器（Iterator）
4. Java8中的Stream

Map集合中常用的遍历方式: 4种

1.使用keySet()方法遍历Map的键：

Map map = new HashMap<>();for (K key : map.keySet()) {    // 处理键key和对应的值map.get(key)}

2.使用entrySet()方法遍历Map的键值对：

Map map = new HashMap<>();for (Map.Entry entry : map.entrySet()) {    K key = entry.getKey();    V value = entry.getValue();    // 处理键key和对应的值value}

3.使用Java 8中的Lambda表达式for-each：

Map map = new HashMap<>();map.forEach((key, value) -> {    // 处理键key和对应的值value});

4.使用Java 8中的Stream()：

Map map = new HashMap<>();map.entrySet().stream().forEach(entry -> {    K key = entry.getKey();    V value = entry.getValue();    // 处理键key和对应的值value});

List集合中常用的遍历方式:7种

1.使用普通的for循环遍历List：

List list = new ArrayList<>();for (int i = 0; i < list.size(); i++) {    T element = list.get(i);    // 处理元素element}

2.使用foreach循环遍历List：

List list = new ArrayList<>();for (T element : list) {    // 处理元素element}

3.使用迭代器（Iterator）遍历List：

List list = new ArrayList<>();Iterator iterator = list.iterator();while (iterator.hasNext()) {    T element = iterator.next();    // 处理元素element}

4.使用结合Lambda表达式遍历List（Java 8+）,forEach的形式:

List list = new ArrayList<>();list.forEach(element -> {    // 处理元素element});

5.使用Java 8的Stream的API遍历List（Java 8+）:

List list = new ArrayList<>();list.stream().forEach(element -> {    // 处理元素element});

6.使用List的listIterator()方法反向遍历List：

List list = new ArrayList<>();ListIterator iterator = list.listIterator(list.size());while (iterator.hasPrevious()) {    T element = iterator.previous();    // 处理元素element}

7.使用List的subList()方法进行分段遍历List：

List list = new ArrayList<>();int batchSize = 10; // 批处理大小for (int i = 0; i < list.size(); i += batchSize) {    List subList = list.subList(i, Math.min(i + batchSize, list.size()));    for (T element : subList) {        // 处理元素element    }}

Map集合中常用的去重方式:3种

1.使用HashMap的keySet()方法去重:

通过将Map的键（key）转换为Set集合，Set集合会自动去重，从而实现Map的去重。

Map map = new HashMap<>();Set uniqueKeys = new HashSet<>(map.keySet());

2.使用LinkedHashMap的keySet（）方法去重:

通过LinkedHashSet会保留元素添加的顺序，同时会过滤掉重复的元素，通过将Map的键转换为LinkedHashSet实现Map的去重。

Map map = new LinkedHashMap<>();Set uniqueKeys = new LinkedHashSet<>(map.keySet());

3.使用Java8里面的stream中的distinct()方法去重:

通过将Map的键转换为流（Stream），使用distinct()方法去除重复元素，然后将流转换回集合。

Map map = new HashMap<>();Set uniqueKeys = map.keySet().stream().distinct().collect(Collectors.toSet());

List集合中常用的去重方式:6种

1.使用HashSet去重：

HashSet是一种基于哈希表实现的集合，它不允许有重复元素，存储的元素是无序的。可以利用HashSet的去重特性来进行List集合的去重。具体步骤如下：

List list = new ArrayList<>();HashSet set = new HashSet<>(list);List uniqueList = new ArrayList<>(set);

2.使用TreeSet去重：

TreeSet是一种有序的集合，它根据元素的自然顺序进行排序，并且不允许有重复元素。可以利用TreeSet的排序和去重特性来进行List集合的去重。具体步骤如下：

List list = new ArrayList<>();TreeSet set = new TreeSet<>(list);List uniqueList = new ArrayList<>(set);

3.使用LinkedHashSet去重：

LinkedHashSet是一种有序的集合，它保留了元素插入的顺序，并且不允许有重复元素。可以利用LinkedHashSet的有序性和去重特性来进行List集合的去重。具体步骤如下：

List list = new ArrayList<>();LinkedHashSet set = new LinkedHashSet<>(list);List uniqueList = new ArrayList<>(set);

 4.使用迭代器去重：

迭代器是一种用于遍历和操作集合的对象，在遍历集合的过程中，可以判断当前元素是否已经存在于另一个集合中，从而实现去重。具体步骤如下：

List list = new ArrayList<>();List uniqueList = new ArrayList<>();Iterator iterator = list.iterator();while (iterator.hasNext()) {    T element = iterator.next();    if (!uniqueList.contains(element)) {        uniqueList.add(element);    }}

5.使用Stream去重：

 使用Java 8引入的Stream API可以方便地进行集合处理和操作，其中的distinct()操作可以去除重复元素。具体步骤如下：

List list = new ArrayList<>();List uniqueList = list.stream().distinct().collect(Collectors.toList());

6.使用contains判断去重：

通过使用List的contains方法来判断元素是否已经存在于另一个集合中,需要遍历整个集合来判断元素是否已经存在，效率较低。具体步骤如下:

List list = new ArrayList<>();List uniqueList = new ArrayList<>();for (T element : list) {    if (!uniqueList.contains(element)) {        uniqueList.add(element);    }}

来源地址：https://blog.csdn.net/weixin_55746254/article/details/131747556