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

Java中常用的遍历方式有：

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

 

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

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

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

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

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

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

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

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

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

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

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

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

2.使用foreach循环遍历List：

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

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

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

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

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

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

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

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

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

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

List<T> list = new ArrayList<>();
int batchSize = 10; // 批处理大小
for (int i = 0; i < list.size(); i += batchSize) {
    List<T> 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<K, V> map = new HashMap<>();
Set<K> uniqueKeys = new HashSet<>(map.keySet());

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

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

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

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

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

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

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

1.使用HashSet去重：

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

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

2.使用TreeSet去重：

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

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

3.使用LinkedHashSet去重：

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

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

 4.使用迭代器去重：

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

List<T> list = new ArrayList<>();
List<T> uniqueList = new ArrayList<>();
Iterator<T> 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<T> list = new ArrayList<>();
List<T> uniqueList = list.stream().distinct().collect(Collectors.toList());

6.使用contains判断去重：

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

List<T> list = new ArrayList<>();
List<T> uniqueList = new ArrayList<>();

for (T element : list) {
    if (!uniqueList.contains(element)) {
        uniqueList.add(element);
    }
}