80个JAVA8函数式编程中关于集合的操作实例（持续更新增加实例）
文章目录
- JAVA8函数式编程中关于集合的各种操作实例（持续更新增加实例）
JAVA8函数式编程中关于集合的各种操作实例（持续更新增加实例）
map - 将集合中的每个元素映射为另一个元素 示例：将数字集合中的每个元素平方并返回平方后的集合。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredNums = nums.stream().map(n -> n * n).collect(Collectors.toList());
filter - 过滤不符合条件的元素，留下符合条件的元素 示例：从字符串集合中过滤出长度大于等于 5 的字符串，并返回过滤后的集合。
List<String> words = Arrays.asList("apple", "banana", "orange", "pear", "peach");
List<String> longWords = words.stream().filter(word -> word.length() >= 5).collect(Collectors.toList());
reduce - 将集合中的所有元素组合成一个值 示例：计算数字集合中所有元素的和。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
int sum = nums.stream().reduce(0, (a, b) -> a + b);
forEach - 对集合中的每个元素执行某个操作 示例：打印数字集合中的每个元素。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
nums.forEach(System.out::println);
sorted - 对集合中的元素进行排序 示例：对字符串集合按照长度进行升序排序。
List<String> words = Arrays.asList("apple", "banana", "orange", "pear", "peach");
List<String> sortedWords = words.stream().sorted((a, b) -> a.length() - b.length()).collect(Collectors.toList());
distinct - 去除集合中的重复元素 示例：从数字集合中去除重复元素，并返回去重后的集合。
List<Integer> nums = Arrays.asList(1, 2, 3, 2, 4, 5, 3, 1);
List<Integer> distinctNums = nums.stream().distinct().collect(Collectors.toList());
limit - 截取集合中的前n个元素 示例：从数字集合中选出前3个元素，并返回截取后的集合。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> limitedNums = nums.stream().limit(3).collect(Collectors.toList());
skip - 跳过集合中的前n个元素 示例：从数字集合中跳过前3个元素，并返回剩余的元素组成的集合。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> skippedNums = nums.stream().skip(3).collect(Collectors.toList());
max - 找出集合中的最大值 示例：找出数字集合中的最大值。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
int maxNum = nums.stream().max(Integer::compare).orElseThrow(NoSuchElementException::new);
min - 找出集合中的最小值 示例：找出数字集合中的最小值。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
int minNum = nums.stream().min(Integer::compare).orElseThrow(NoSuchElementException::new);
anyMatch - 判断集合中是否存在符合条件的元素 示例：判断数字集合中是否存在偶数。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
boolean hasEven = nums.stream().anyMatch(n -> n % 2 == 0);
allMatch - 判断集合中的所有元素是否都符合条件 示例：判断数字集合中是否所有元素都是偶数。
List<Integer> nums = Arrays.asList(2, 4, 6, 8, 10);
boolean allEven = nums.stream().allMatch(n -> n % 2 == 0);
noneMatch - 判断集合中是否不存在符合条件的元素 示例：判断数字集合中是否不存在负数。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
boolean noNegative = nums.stream().noneMatch(n -> n < 0);
findFirst - 找出集合中第一个符合条件的元素 示例：从数字集合中找出第一个偶数。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
int firstEven = nums.stream().filter(n -> n % 2 == 0).findFirst().orElseThrow(NoSuchElementException::new);
findAny - 找出集合中任意一个符合条件的元素 示例：从数字集合中找出任意一个偶数。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> anyEven = nums.stream().filter(n -> n % 2 == 0).findAny();
count - 统计集合中符合条件的元素个数 示例：统计数字集合中偶数的个数。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
long evenCount = nums.stream().filter(n -> n % 2 == 0).count();
flatMap - 将嵌套集合中的元素展平成一维集合 示例：将二维数字集合中的所有元素展平成一维集合，并去重后返回。
List<List<Integer>> nums = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(2, 3), Arrays.asList(3, 4));
List<Integer> flattenedNums = nums.stream().flatMap(Collection::stream).distinct().collect(Collectors.toList());
partitioningBy - 根据条件对集合进行分区，分成两个区域，符合条件的在一个区域，不符合条件的在另一个区域 示例：将数字集合分成奇数和偶数两个区域，并返回分区后的结果。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List<Integer>> partitionedNums = nums.stream().collect(Collectors.partitioningBy(n -> n % 2 == 0));
groupingBy - 根据条件对集合进行分组 示例：将字符串集合按照首字母进行分组，并返回分组后的结果。
List<String> words = Arrays.asList("apple", "banana", "orange", "pear", "peach");
Map<Character, List<String>> groupedWords = words.stream().collect(Collectors.groupingBy(word -> word.charAt(0)));
toSet - 将集合转换为Set类型 示例：将数字集合转换为Set类型，并返回转换后的结果。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
Set<Integer> numSet = nums.stream().collect(Collectors.toSet());
toMap - 将集合转换为Map类型 示例：将字符串集合按照长度作为键创建Map，并返回创建后的Map。
List<String> words = Arrays.asList("apple", "banana", "orange", "pear", "peach");
Map<Integer, String> wordMap = words.stream().collect(Collectors.toMap(String::length, Function.identity()));
toCollection - 自定义集合类型 示例：将数字集合转换为LinkedList类型，并返回转换后的结果。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
LinkedList<Integer> linkedList = nums.stream().collect(Collectors.toCollection(LinkedList::new));
toArray - 将集合转换为数组类型 示例：将数字集合转换为数组类型，并返回转换后的结果。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
Integer[] numArr = nums.stream().toArray(Integer[]::new);
concat - 连接两个集合 示例：将两个字符串集合连接起来，并返回连接后的集合。
List<String> words1 = Arrays.asList("apple", "banana");
List<String> words2 = Arrays.asList("orange", "pear", "peach");
List<String> concatenatedWords = Stream.concat(words1.stream(), words2.stream()).collect(Collectors.toList());
peek - 对流中的每个元素进行调试操作，不改变流中元素的值 示例：打印数字集合中的偶数，并返回原始流。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
nums.stream().peek(n -> {
if (n % 2 == 0) {
System.out.println(n);
}
}).collect(Collectors.toList());
flatMapToInt - 将集合中的元素展平为int类型的一维数组 示例：将二维数字集合中的所有元素展平为int类型的一维数组，并返回。
List<List<Integer>> nums = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(2, 3), Arrays.asList(3, 4));
int[] flattenedNums = nums.stream().flatMapToInt(list -> list.stream().mapToInt(Integer::intValue)).toArray();
flatMapToLong - 将集合中的元素展平为long类型的一维数组 示例：将二维数字集合中的所有元素展平为long类型的一维数组，并返回。
List<List<Long>> nums = Arrays.asList(Arrays.asList(1L, 2L), Arrays.asList(2L, 3L), Arrays.asList(3L, 4L));
long[] flattenedNums = nums.stream().flatMapToLong(list -> list.stream().mapToLong(Long::longValue)).toArray();
flatMapToDouble - 将集合中的元素展平为double类型的一维数组 示例：将二维数字集合中的所有元素展平为double类型的一维数组，并返回。
List<List<Double>> nums = Arrays.asList(Arrays.asList(1.0, 2.0), Arrays.asList(2.0, 3.0), Arrays.asList(3.0, 4.0));
double[] flattenedNums = nums.stream().flatMapToDouble(list -> list.stream().mapToDouble(Double::doubleValue)).toArray();
summarizeInt - 统计集合中元素的总和、个数、最大值、最小值和平均值 示例：统计数字集合中元素的总和、个数、最大值、最小值和平均值。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
IntSummaryStatistics stats = nums.stream().mapToInt(Integer::intValue).summaryStatistics();
int sum = stats.getSum();
int count = stats.getCount();
int max = stats.getMax();
int min = stats.getMin();
double average = stats.getAverage();
summarizeLong - 统计集合中元素的总和、个数、最大值、最小值和平均值 示例：统计Long类型数字集合中元素的总和、个数、最大值、最小值和平均值。
List<Long> nums = Arrays.asList(1L, 2L, 3L, 4L, 5L);
LongSummaryStatistics stats = nums.stream().mapToLong(Long::longValue).summaryStatistics();
long sum = stats.getSum();
long count = stats.getCount();
long max = stats.getMax();
long min = stats.getMin();
double average = stats.getAverage();
summarizeDouble - 统计集合中元素的总和、个数、最大值、最小值和平均值 示例：统计double类型数字集合中元素的总和、个数、最大值、最小值和平均值。
List<Double> nums = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0);
DoubleSummaryStatistics stats = nums.stream().mapToDouble(Double::doubleValue).summaryStatistics();
double sum = stats.getSum();
long count = stats.getCount();
double max = stats.getMax();
double min = stats.getMin();
double average = stats.getAverage();
reduce(Map.Entry
List<String> words = Arrays.asList("apple", "banana", "orange", "pear", "peach");
Map<Character, Integer> wordCountMap = words.stream().reduce(
new HashMap<Character, Integer>(),
(map, word) -> {
char firstChar = word.charAt(0);
map.put(firstChar, map.getOrDefault(firstChar, 0) + 1);
return map;
},
(map1, map2) -> {
map2.forEach((key, value) -> map1.merge(key, value, Integer::sum));
return map1;
}
);
matching(Predicate predicate) - 判断流中是否有元素满足给定的条件，返回一个boolean类型的值 示例：判断数字集合中是否存在大于10的元素。
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 10, 20, 30);
boolean hasLargeNum = nums.stream().anyMatch(n -> n > 10);
peek(Consumer action) - 对流中每个元素执行给定的操作，返回一个新流 示例：将字符串集合中的所有元素转换为大写，并返回转换后的集合。
List<String> words = Arrays.asList("apple", "banana", "orange", "pear", "peach");
List<String> upperCaseWords = words.stream().peek(word -> word.toUpperCase()).collect(Collectors.toList());
sorted(Comparator comparator) - 使用给定的比较器对流进行排序 示例：将数字集合按照绝对值进行升序排序，并返回排序后的集合。
List<Integer> nums = Arrays.asList(-2, 1, 3, -4, 5);
List<Integer> sortedNums = nums.stream().sorted(Comparator.comparing(Math::abs)).collect(Collectors.toList());
limit(long maxSize) - 返回一个不超过指定数量的元素的流 示例：返回数字集合中前3个正整数，并返回截取后的集合。
List<Integer> nums = Arrays.asList(-2, 1, 3, -4, 5);
List<Integer> limitedNums = nums.stream().filter(n -> n > 0).limit(3).collect(Collectors.toList());
skip(long n) - 跳过指定数量的元素，返回剩余元素组成的流 示例：跳过数字集合中前3个负整数，并返回剩余的元素组成的集合。
List<Integer> nums = Arrays.asList(-2, 1, 3, -4, 5);
List<Integer> skippedNums = nums.stream().filter(n -> n > 0).skip(3).collect(Collectors.toList());
遍历集合中的元素
List<String> list = Arrays.asList("apple", "banana", "orange");
list.forEach(System.out::println);
过滤集合中的元素
List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream()
.filter(s -> s.startsWith("a"))
.collect(Collectors.toList());
System.out.println(filteredList);
映射集合中的元素
List<String> list = Arrays.asList("apple", "banana", "orange");
List<Integer> lengths = list.stream()
.map(String::length)
.collect(Collectors.toList());
System.out.println(lengths);
统计集合中的元素
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
IntSummaryStatistics stats = list.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("Max: " + stats.getMax());
System.out.println("Min: " + stats.getMin());
System.out.println("Sum: " + stats.getSum());
System.out.println("Average: " + stats.getAverage());
排序集合中的元素
List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> sortedList = list.stream()
.sorted()
.collect(Collectors.toList());
System.out.println(sortedList);
取出集合中的前n个元素
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> subList = list.stream()
.limit(3)
.collect(Collectors.toList());
System.out.println(subList);
跳过集合中的前n个元素
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> subList = list.stream()
.skip(3)
.collect(Collectors.toList());
System.out.println(subList);
合并两个集合
List<String> list1 = Arrays.asList("apple", "banana");
List<String> list2 = Arrays.asList("orange", "grape");
List<String> mergedList = Stream.concat(list1.stream(), list2.stream())
.collect(Collectors.toList());
System.out.println(mergedList);
判断集合中是否存在满足条件的元素
List<String> list = Arrays.asList("apple", "banana", "orange");
boolean hasMatch = list.stream()
.anyMatch(s -> s.startsWith("a"));
System.out.println(hasMatch);
判断集合中所有元素是否都满足条件
List<String> list = Arrays.asList("apple", "banana", "orange");
boolean allMatch = list.stream()
.allMatch(s -> s.length() > 3);
System.out.println(allMatch);
判断集合中是否所有元素都不满足条件
List<String> list = Arrays.asList("apple", "banana", "orange");
boolean noneMatch = list.stream()
.noneMatch(s -> s.contains("pear"));
System.out.println(noneMatch);
将集合中的元素连接成一个字符串
List<String> list = Arrays.asList("apple", "banana", "orange");
String joined = list.stream()
.collect(Collectors.joining(", "));
System.out.println(joined);
将集合中的元素分组
List<String> list = Arrays.asList("apple", "banana", "orange");
Map<Integer, List<String>> grouped = list.stream()
.collect(Collectors.groupingBy(String::length));
System.out.println(grouped);
将集合中的元素分区
List<String> list = Arrays.asList("apple", "banana", "orange");
Map<Boolean, List<String>> partitioned = list.stream()
.collect(Collectors.partitioningBy(s -> s.startsWith("a")));
System.out.println(partitioned);
计算集合中的元素个数
List<String> list = Arrays.asList("apple", "banana", "orange");
long count = list.stream().count();
System.out.println(count);
获取集合中的最大值和最小值
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = list.stream().max(Integer::compare);
Optional<Integer> min = list.stream().min(Integer::compare);
System.out.println("Max: " + max.get());
System.out.println("Min: " + min.get());
将集合中的元素转换为数组
List<String> list = Arrays.asList("apple", "banana", "orange");
String[] array = list.stream().toArray(String[]::new);
System.out.println(Arrays.toString(array));
将集合中的元素转换为Set
List<String> list = Arrays.asList("apple", "banana", "orange");
Set<String> set = list.stream().collect(Collectors.toSet());
System.out.println(set);
将集合中的元素转换为Map
List<String> list = Arrays.asList("apple", "banana", "orange");
Map<String, Integer> map = list.stream()
.collect(Collectors.toMap(Function.identity(), String::length));
System.out.println(map);
将集合中的元素去重
List<String> list = Arrays.asList("apple", "banana", "orange", "apple");
List<String> distinctList = list.stream().distinct().collect(Collectors.toList());
System.out.println(distinctList);
将集合中的元素转换为大写
List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> upperList = list.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(upperList);
将集合中的元素按照某个属性进行排序
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20)
);
List<Person> sortedList = list.stream()
.sorted(Comparator.comparing(Person::getAge))
.collect(Collectors.toList());
System.out.println(sortedList);
将集合中的元素按照某个属性进行降序排序
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20)
);
List<Person> sortedList = list.stream()
.sorted(Comparator.comparing(Person::getAge).reversed())
.collect(Collectors.toList());
System.out.println(sortedList);
将集合中的元素取平均值
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
double average = list.stream().mapToInt(Integer::intValue).average().getAsDouble();
System.out.println(average);
将集合中的元素取最大值
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int max = list.stream().mapToInt(Integer::intValue).max().getAsInt();
System.out.println(max);
将集合中的元素取最小值
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int min = list.stream().mapToInt(Integer::intValue).min().getAsInt();
System.out.println(min);
将集合中的元素累加
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().mapToInt(Integer::intValue).sum();
System.out.println(sum);
将集合中的元素按照属性分组并统计个数
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25)
);
Map<Integer, Long> grouped = list.stream()
.collect(Collectors.groupingBy(Person::getAge, Collectors.counting()));
System.out.println(grouped);
将集合中的元素按照属性分组并统计属性值之和
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25)
);
Map<Integer, Integer> grouped = list.stream()
.collect(Collectors.groupingBy(Person::getAge, Collectors.summingInt(Person::getAge)));
System.out.println(grouped);
将集合中的元素按照属性分组并统计属性值平均值
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25)
);
Map<Integer, Double> grouped = list.stream()
.collect(Collectors.groupingBy(Person::getAge, Collectors.averagingInt(Person::getAge)));
System.out.println(grouped);
将集合中的元素按照属性分组并将属性值转换为另一种类型
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25)
);
Map<Integer, List<String>> grouped = list.stream()
.collect(Collectors.groupingBy(Person::getAge, Collectors.mapping(Person::getName, Collectors.toList())));
System.out.println(grouped);
将集合中的元素按照属性分组并将属性值排序
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25)
);
Map<Integer, List<Person>> grouped = list.stream()
.collect(Collectors.groupingBy(Person::getAge, Collectors.toList()));
grouped.forEach((age, people) -> {
System.out.println("Age: " + age);
List<Person> sortedPeople = people.stream()
.sorted(Comparator.comparing(Person::getName))
.collect(Collectors.toList());
System.out.println(sortedPeople);
});
将集合中的元素按照属性分组并将属性值转换为Map
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25)
);
Map<Integer, Map<String, Integer>> grouped = list.stream()
.collect(Collectors.groupingBy(Person::getAge, Collectors.toMap(Person::getName, Person::getAge)));
System.out.println(grouped);
将集合中的元素按照属性分组并将属性值转换为Set
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25)
);
Map<Integer, Set<String>> grouped = list.stream()
.collect(Collectors.groupingBy(Person::getAge, Collectors.mapping(Person::getName, Collectors.toSet())));
System.out.println(grouped);
将集合中的元素按照属性分组并将属性值转换为List后拼接成字符串
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25)
);
Map<Integer, String> grouped = list.stream()
.collect(Collectors.groupingBy(Person::getAge, Collectors.mapping(Person::getName, Collectors.joining(", "))));
System.out.println(grouped);
将集合中的元素按照多个属性分组
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25)
);
Map<List<Object>, List<Person>> grouped = list.stream()
.collect(Collectors.groupingBy(p -> Arrays.asList(p.getName(), p.getAge())));
System.out.println(grouped);
将集合中的元素按照多个属性分组并统计个数
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25),
new Person("Tom", 25)
);
Map<List<Object>, Long> grouped = list.stream()
.collect(Collectors.groupingBy(p -> Arrays.asList(p.getName(), p.getAge()), Collectors.counting()));
System.out.println(grouped);
将集合中的元素按照多个属性分组并统计属性值之和
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25),
new Person("Tom", 25)
);
Map<List<Object>, Integer> grouped = list.stream()
.collect(Collectors.groupingBy(p -> Arrays.asList(p.getName(), p.getAge()), Collectors.summingInt(Person::getAge)));
System.out.println(grouped);
将集合中的元素按照多个属性分组并统计属性值平均值
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25),
new Person("Tom", 25)
);
Map<List<Object>, Double> grouped = list.stream()
.collect(Collectors.groupingBy(p -> Arrays.asList(p.getName(), p.getAge()), Collectors.averagingInt(Person::getAge)));
System.out.println(grouped);
将集合中的元素按照多个属性分组并将属性值转换为另一种类型
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25),
new Person("Tom", 25)
);
Map<List<Object>, List<String>> grouped = list.stream()
.collect(Collectors.groupingBy(p -> Arrays.asList(p.getName(), p.getAge()), Collectors.mapping(Person::getName, Collectors.toList())));
System.out.println(grouped);
将集合中的元素按照多个属性分组并将属性值排序
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25),
new Person("Tom", 25)
);
Map<List<Object>, List<Person>> grouped = list.stream()
.collect(Collectors.groupingBy(p -> Arrays.asList(p.getName(), p.getAge()), Collectors.toList()));
grouped.forEach((keys, people) -> {
System.out.println("Name: " + keys.get(0) + ", Age: " + keys.get(1));
List<Person> sortedPeople = people.stream()
.sorted(Comparator.comparing(Person::getName))
.collect(Collectors.toList());
System.out.println(sortedPeople);
});
将集合中的元素按照多个属性分组并将属性值转换为Map
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25),
new Person("Tom", 25)
);
Map<List<Object>, Map<String, Integer>> grouped = list.stream()
.collect(Collectors.groupingBy(p -> Arrays.asList(p.getName(), p.getAge()), Collectors.toMap(Person::getName, Person::getAge)));
System.out.println(grouped);
将集合中的元素按照多个属性分组并将属性值转换为Set
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25),
new Person("Tom", 25)
);
Map<List<Object>, Set<String>> grouped = list.stream()
.collect(Collectors.groupingBy(p -> Arrays.asList(p.getName(), p.getAge()), Collectors.mapping(Person::getName, Collectors.toSet())));
System.out.println(grouped);
将集合中的元素按照多个属性分组并将属性值转换为List后拼接成字符串
List<Person> list = Arrays.asList(
new Person("Tom", 25),
new Person("Jack", 30),
new Person("Alice", 20),
new Person("Bob", 25),
new Person("Tom", 25)
);
Map<List<Object>, String> grouped = list.stream()
.collect(Collectors.groupingBy(p -> Arrays.asList(p.getName(), p.getAge()), Collectors.mapping(User::getAge, Collectors.toList())));