文章/答案/技术大牛

发布

社区首页 >专栏 >80个JAVA8函数式编程中关于集合的操作实例（持续更新增加实例）

80个JAVA8函数式编程中关于集合的操作实例（持续更新增加实例）

青山师

发布于 2023-05-05 12:14:50

1K00

代码可运行

文章被收录于专栏：IT当时语_青山师_JAVA技术栈IT当时语_青山师_JAVA技术栈

运行总次数：0

代码可运行

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<K, V> identity, BinaryOperator<Map.Entry<K, V>> accumulator, BinaryOperator<Map.Entry<K, V>> combiner) - 根据给定的初始值和累加器将元素逐个结合，类似于reduce操作，只不过针对Map的键值对示例：将字符串集合中的所有元素按照首字母分组，并统计每个分组中元素的个数。

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())));