Java中常用的遍历方式有:
- 普通for循环
- for-each循环
- 使用迭代器(Iterator)
- 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); } }