Java使用Stream API对于数据列表经常处理

先提供一些简单到复杂的常见例子，您可以根据这些例子进行进一步的开发和学习：

数据过滤筛选操作

1. 查询表中所有数据：

List<User> users = userDao.getAllUsers();

2. 根据条件查询单个结果：

Optional<User> user = userDao.getUserById(userId);

3. 根据条件查询多个结果，并取前几条：

List<User> topUsers = userDao.getTopUsersByScore(10);

4. 对查询结果进行排序：

List<User> sortedUsers = userDao.getAllUsers()
    .stream()
    .sorted(Comparator.comparing(User::getScore))
    .collect(Collectors.toList());

5. 过滤符合条件的结果：

List<User> filteredUsers = userDao.getAllUsers()
    .stream()
    .filter(user -> user.getAge() >= 18)
    .collect(Collectors.toList());

6. 对查询结果进行分页：

int pageSize = 10;
int pageNum = 1;
List<User> pageUsers = userDao.getAllUsers()
    .stream()
    .skip((pageNum - 1) * pageSize)
    .limit(pageSize)
    .collect(Collectors.toList());

7. 对查询结果进行统计：

long totalUserCount = userDao.getAllUsers().stream().count();

8. 对查询结果进行求和：

int totalScores = userDao.getAllUsers()
    .stream()
    .mapToInt(User::getScore)
    .sum();

9. 对查询结果进行分组：

Map<Integer, List<User>> ageGroup = userDao.getAllUsers()
    .stream()
    .collect(Collectors.groupingBy(User::getAge));

10. 对查询结果进行去重：

List<String> distinctNames = userDao.getAllUsers()
    .stream()
    .map(User::getName)
    .distinct()
    .collect(Collectors.toList());

数据进行计算筛选

1. 计算一个整数列表中所有偶数的和：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.stream()
                .filter(n -> n % 2 == 0)
                .mapToInt(Integer::intValue)
                .sum();
System.out.println("偶数之和：" + sum);

2. 统计一个字符串列表中每个单词出现的次数：

List<String> words = Arrays.asList("apple", "banana", "orange", "apple", "banana", "apple");
Map<String, Long> wordCounts = words.stream()
                .flatMap(word -> Arrays.stream(word.split("\\s+")))
                .collect(Collectors.groupingBy(String::toLowerCase, Collectors.counting()));
System.out.println("单词出现次数：" + wordCounts);

3. 将一个整数列表按照指定的规则进行分组：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Map<Integer, List<Integer>> groupedNumbers = numbers.stream()
                .collect(Collectors.groupingBy(n -> (n - 1) % 3));
System.out.println("分组结果：" + groupedNumbers);

4. 对一个用户列表按照年龄进行降序排序：

List<User> users = Arrays.asList(new User("Alice", 25), new User("Bob", 30), new User("Cathy", 20));
users.sort((u1, u2) -> u2.getAge() - u1.getAge());
System.out.println("按年龄降序排序的用户列表：" + users);

5. 对一个字符串列表进行去重操作：

List<String> uniqueWords = Arrays.asList("apple", "banana", "orange", "apple", "banana").stream()
                .distinct()
                .collect(Collectors.toList());
System.out.println("去重后的字符串列表：" + uniqueWords);

6. 对一个整数列表进行前N个最大值的筛选：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int N = 3;
List<Integer> topNMaxValues = numbers.stream()
                .limit(N)
                .max(Comparator.naturalOrder())
                .collect(Collectors.toList());
System.out.println("前N个最大值：" + topNMaxValues);

7. 对一个整数列表进行前N个最小值的筛选：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int N = 3;
List<Integer> topNMinValues = numbers.stream()
                .limit(N)
                .min(Comparator.naturalOrder())
                .collect(Collectors.toList());
System.out.println("前N个最小值：" + topNMinValues);

8. 对一个整数列表进行前N个平均值的筛选：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int N = 3;
double sum = numbers.stream()
                .limit(N)
                .reduce(0L, (a, b) -> a + b); // 先计算总和再除以N得到平均值
List<Double> topNAverageValues = numbers.stream()
                .limit(N)
                .mapToDouble(Integer::intValue) // 将整数转换为浮点数进行计算平均值
                .sorted() // 按升序排序后取前N个平均值作为结果列表的元素
                .collect(Collectors.toList());
System.out.println("前N个平均值：" + topNAverageValues);

方法融合

我可以给您一个示例，展示如何在Java Stream中融合使用不同的方法：

假设有一个User类，包含name（姓名）、age（年龄）和score（分数）属性。我们使用Java Stream来对一组User对象进行操作。

List<User> users = ... // 获取User列表

// 示例1: 过滤、排序并限制结果数量
List<String> names = users.stream()
    .filter(user -> user.getAge() >= 18) // 过滤年龄大于等于18岁的用户
    .sorted(Comparator.comparing(User::getScore).reversed()) // 按照分数降序排序
    .limit(5) // 限制结果数量为5个
    .map(User::getName) // 提取姓名字段
    .collect(Collectors.toList());

System.out.println(names); // 打印结果

// 示例2: 分组、求和、统计
Map<Integer, Long> ageCountMap = users.stream()
    .collect(Collectors.groupingBy(User::getAge, Collectors.counting())); // 按照年龄分组并统计数量

int totalScore = users.stream()
    .mapToInt(User::getScore) // 转换成IntStream
    .sum(); // 求和

System.out.println(ageCountMap);
System.out.println(totalScore);

// 示例3: 映射、去重
Set<String> uniqueNames = users.stream()
    .map(User::getName) // 提取姓名字段
    .distinct() // 去重
    .collect(Collectors.toSet()); // 转换为Set集合

System.out.println(uniqueNames);

// 示例4: 并行处理
int totalAge = users.parallelStream()
    .mapToInt(User::getAge)
    .sum();

System.out.println(totalAge);

以上示例展示了不同的Stream方法的融合应用，如过滤(filter)、排序(sorted)、限制(limit)、映射(map)、分组(groupingBy)、求和(sum)、去重(distinct)等。您可以根据需求，在您的项目中融合使用这些方法来处理数据。如果有具体的问题或需求，欢迎继续向我提问。