Java中使用List的stream流19中常用方法操作以及使用常用的filter、map、distinct、count、collect、skip、limit等方法进行数据列表的处理以及数据列表的分页

最新推荐文章于 2024-05-09 15:12:33 发布
最新推荐文章于 2024-05-09 15:12:33 发布
阅读量520 收藏 4
点赞数 8
分类专栏： Spring学习笔记 Java学习笔记 文章标签： java list python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44912902/article/details/138188341
版权

假设我有一个User类

// 示例数据
List<User> users = Arrays.asList(
    new User("Alice", 25, "Female"),
    new User("Bob", 30, "Male"),
    new User("Charlie", 35, "Male"),
    new User("Dave", 40, "Male"),
    new User("Eve", 22, "Female")
);

stream流19种常用方法

  • filter通过给定的条件（谓词）筛选流中的元素。

filter(Predicate<? super T> predicate)：

// 1. filter(Predicate<? super T> predicate)：筛选年龄大于30的用户
List<User> filteredUsers = users.stream()
                                .filter(user -> user.getAge() > 30)
                                .collect(Collectors.toList());
System.out.println("年龄大于30的用户：" + filteredUsers);
  • map将流中的每个元素映射为另一个值。

map(Function<? super T, ? extends R> mapper)：

// 2. map(Function<? super T, ? extends R> mapper)：转换为名称列表
List<String> names = users.stream()
                          .map(User::getName)
                          .collect(Collectors.toList());
System.out.println("名称列表：" + names);
  • flatMap将流中的每个元素映射为一个流，然后将这些流连接成一个流。

flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)：

// 3. flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)：拆分名称为字符列表
List<String> letters = users.stream()
                            .flatMap(user -> Arrays.stream(user.getName().split("")))
                            .collect(Collectors.toList());
System.out.println("拆分后的字母：" + letters);
  • distinct去除流中的重复元素。

distinct()：

// 4. distinct()：去重性别
List<String> uniqueGenders = users.stream()
                                  .map(User::getSex)
                                  .distinct()
                                  .collect(Collectors.toList());
System.out.println("去重后的性别：" + uniqueGenders);
  • sorted对流中的元素进行自然排序。

sorted()：

// 5. sorted()：按年龄自然排序
List<User> sortedUsersByAge = users.stream()
                                   .sorted((user1, user2) -> Integer.compare(user1.getAge(), user2.getAge()))
                                   .collect(Collectors.toList());
System.out.println("按年龄排序：" + sortedUsersByAge);
  • sorted使用自定义比较器对流中的元素进行排序。

sorted(Comparator<? super T> comparator)：

// 6. sorted(Comparator<? super T> comparator)：按名称长度排序
List<User> sortedUsersByNameLength = users.stream()
                                          .sorted((user1, user2) -> Integer.compare(user1.getName().length(), user2.getName().length()))
                                          .collect(Collectors.toList());
System.out.println("按名称长度排序：" + sortedUsersByNameLength);
  • peek对流中的每个元素执行操作，但不改变流中的元素。

peek(Consumer<? super T> action)：

// 7. peek(Consumer<? super T> action)：打印每个用户
users.stream()
     .peek(System.out::println)
     .collect(Collectors.toList());
  • limit截断流，使其最多只包含指定数量的元素。

limit(long maxSize)：

// 8. limit(long maxSize)：限制数量
List<User> limitedUsers = users.stream()
                               .limit(2)
                               .collect(Collectors.toList());
System.out.println("前两个用户：" + limitedUsers);
  • skip跳过指定数量的元素，返回剩余的元素组成的流。

skip(long n)：

// 9. skip(long n)：跳过前两个用户
List<User> skippedUsers = users.stream()
                               .skip(2)
                               .collect(Collectors.toList());
System.out.println("跳过前两个用户：" + skippedUsers);
  • forEach对流中的每个元素执行操作。

forEach(Consumer<? super T> action)：

// 10. forEach(Consumer<? super T> action)：遍历打印
System.out.println("打印每个用户：");
users.stream()
     .forEach(System.out::println);
  • toArray将流中的元素收集到一个数组中。

toArray()：

// 11. toArray()：转换为数组
User[] usersArray = users.stream()
                         .toArray(User[]::new);
System.out.println("用户数组：" + Arrays.toString(usersArray));
  • reduce使用给定的初始值和二元运算符将流中的元素合并为单个值。

reduce(T identity, BinaryOperator<T> accumulator)：

// 12. reduce(BinaryOperator<T> accumulator)：累加所有年龄
int totalAge = users.stream()
                    .map(User::getAge)
                    .reduce(0, Integer::sum);
System.out.println("所有用户年龄总和：" + totalAge);
  • collect将流中的元素收集到一个结果容器中，如列表、集合、映射等。

collect(Collector<? super T, A, R> collector)：

// 13. collect(Collector<? super T, A, R> collector)：按性别收集为Map
Map<String, List<User>> genderGroup = users.stream()
                                             .collect(Collectors.groupingBy(User::getSex));
System.out.println("按性别分组：" + genderGroup);
  • count计算流中的元素个数。

count()：

// 14. count()：计数
long userCount = users.stream()
                       .count();
System.out.println("用户数量：" + userCount);
  • anyMatch检查流中是否至少有一个元素满足给定条件。

anyMatch(Predicate<? super T> predicate)：

 // 15. anyMatch(Predicate<? super T> predicate)：是否存在年龄大于30的用户
 boolean anyOlderThan30 = users.stream()
                               .anyMatch(user -> user.getAge() > 30);
 System.out.println("是否存在年龄大于30的用户：" + anyOlderThan30);
  • allMatch检查流中的所有元素是否都满足给定条件。

allMatch(Predicate<? super T> predicate)：

// 16. allMatch(Predicate<? super T> predicate)：是否全部是女性
boolean allFemale = users.stream()
                         .allMatch(user -> "Female".equals(user.getSex()));
System.out.println("是否全部是女性：" + allFemale);
  • noneMatch检查流中是否没有任何元素满足给定条件。

noneMatch(Predicate<? super T> predicate)：

// 17. noneMatch(Predicate<? super T> predicate)：是否没有未成年用户
boolean noneUnder18 = users.stream()
                           .noneMatch(user -> user.getAge() < 18);
System.out.println("是否没有未成年用户：" + noneUnder18);
  • findFirst返回流中的第一个元素（如果存在）。

findFirst()：

// 18. findFirst()：获取第一个用户
Optional<User> firstUser = users.stream()
                                .findFirst();
System.out.println("第一个用户：" + firstUser.orElse(new User("", 0, "")));
  • findAny返回流中的任意一个元素（如果存在）。

findAny()：

// 19. findAny()：获取任意一个用户
Optional<User> anyUser = users.stream()
                              .findAny();
System.out.println("任意一个用户：" + anyUser.orElse(new User("", 0, "")));

使用skip和limit进行列表的分页操作

int size = 2; // 每页显示的数量
int current = 1; // 页码，从1开始

List<User> usersPerPage = users.stream()
                               .skip((current- 1) * size) // 跳过之前的页数
                               .limit(size) // 限制每页的数量
                               .collect(Collectors.toList());

System.out.println("第" + pageNumber + "页的用户：" + usersPerPage);

完整代码示例

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // 示例数据
        List<User> users = Arrays.asList(
            new User("Alice", 25, "Female"),
            new User("Bob", 30, "Male"),
            new User("Charlie", 35, "Male"),
            new User("Dave", 40, "Male"),
            new User("Eve", 22, "Female")
        );

        // 1. filter(Predicate<? super T> predicate)：筛选年龄大于30的用户
        List<User> filteredUsers = users.stream()
                                        .filter(user -> user.getAge() > 30)
                                        .collect(Collectors.toList());
        System.out.println("年龄大于30的用户：" + filteredUsers);

        // 2. map(Function<? super T, ? extends R> mapper)：转换为名称列表
        List<String> names = users.stream()
                                  .map(User::getName)
                                  .collect(Collectors.toList());
        System.out.println("名称列表：" + names);

        // 3. flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)：拆分名称为字符列表
        List<String> letters = users.stream()
                                    .flatMap(user -> Arrays.stream(user.getName().split("")))
                                    .collect(Collectors.toList());
        System.out.println("拆分后的字母：" + letters);

        // 4. distinct()：去重性别
        List<String> uniqueGenders = users.stream()
                                          .map(User::getSex)
                                          .distinct()
                                          .collect(Collectors.toList());
        System.out.println("去重后的性别：" + uniqueGenders);

        // 5. sorted()：按年龄自然排序
        List<User> sortedUsersByAge = users.stream()
                                           .sorted((user1, user2) -> Integer.compare(user1.getAge(), user2.getAge()))
                                           .collect(Collectors.toList());
        System.out.println("按年龄排序：" + sortedUsersByAge);

        // 6. sorted(Comparator<? super T> comparator)：按名称长度排序
        List<User> sortedUsersByNameLength = users.stream()
                                                  .sorted((user1, user2) -> Integer.compare(user1.getName().length(), user2.getName().length()))
                                                  .collect(Collectors.toList());
        System.out.println("按名称长度排序：" + sortedUsersByNameLength);

        // 7. peek(Consumer<? super T> action)：打印每个用户
        users.stream()
             .peek(System.out::println)
             .collect(Collectors.toList());

        // 8. limit(long maxSize)：限制数量
        List<User> limitedUsers = users.stream()
                                       .limit(2)
                                       .collect(Collectors.toList());
        System.out.println("前两个用户：" + limitedUsers);

        // 9. skip(long n)：跳过前两个用户
        List<User> skippedUsers = users.stream()
                                       .skip(2)
                                       .collect(Collectors.toList());
        System.out.println("跳过前两个用户：" + skippedUsers);

        // 10. forEach(Consumer<? super T> action)：遍历打印
        System.out.println("打印每个用户：");
        users.stream()
             .forEach(System.out::println);

        // 11. toArray()：转换为数组
        User[] usersArray = users.stream()
                                 .toArray(User[]::new);
        System.out.println("用户数组：" + Arrays.toString(usersArray));

        // 12. reduce(BinaryOperator<T> accumulator)：累加所有年龄
        int totalAge = users.stream()
                            .map(User::getAge)
                            .reduce(0, Integer::sum);
        System.out.println("所有用户年龄总和：" + totalAge);

        // 13. collect(Collector<? super T, A, R> collector)：按性别收集为Map
        Map<String, List<User>> genderGroup = users.stream()
                                                     .collect(Collectors.groupingBy(User::getSex));
        System.out.println("按性别分组：" + genderGroup);

        // 14. count()：计数
        long userCount = users.stream()
                               .count();
        System.out.println("用户数量：" + userCount);

        // 15. anyMatch(Predicate<? super T> predicate)：是否存在年龄大于30的用户
        boolean anyOlderThan30 = users.stream()
                                      .anyMatch(user -> user.getAge() > 30);
        System.out.println("是否存在年龄大于30的用户：" + anyOlderThan30);

        // 16. allMatch(Predicate<? super T> predicate)：是否全部是女性
        boolean allFemale = users.stream()
                                 .allMatch(user -> "Female".equals(user.getSex()));
        System.out.println("是否全部是女性：" + allFemale);

        // 17. noneMatch(Predicate<? super T> predicate)：是否没有未成年用户
        boolean noneUnder18 = users.stream()
                                   .noneMatch(user -> user.getAge() < 18);
        System.out.println("是否没有未成年用户：" + noneUnder18);

        // 18. findFirst()：获取第一个用户
        Optional<User> firstUser = users.stream()
                                        .findFirst();
        System.out.println("第一个用户：" + firstUser.orElse(new User("", 0, "")));

        // 19. findAny()：获取任意一个用户
        Optional<User> anyUser = users.stream()
                                      .findAny();
        System.out.println("任意一个用户：" + anyUser.orElse(new User("", 0, "")));
    }
}

class User {
    private String name;
    private int age;
    private String sex;

    public User(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }

    @Override
    public String toString() {
        return "User{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", sex='" + sex + '\'' +
               '}';
    }
}
令人作呕的溏心蛋
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java stream过滤_Java Stream过滤器
从零开始的教程世界
07-16 1万+
java stream过滤Java Stream filter can be very helpful when you want to do some processing only on some elements of the Stream based on certain condition. 当您希望仅基于特定条件对Stream的某些元素进行某些处理时，Java Stream过滤器可能会...
Java8中 stream，filter 等功能代替for循环（及）isPresent( ) 和 ifPresent() 简单应用
_夜渐凉
09-28 9万+
直接上代码，比较实在。 对象A public Class A{ private Long id; private String userName; ....省略get和set方法 } 在List<A>中，查找 userName 为 "小明" 的对象 A。 在java8中，我们可以这么玩 1，查找集合中符合条件的第一个对象，如果可以明确条...
List＜Map＞的分页方式
最新发布
qq_57147093的博客
05-09 270
这意味着如果resultList的大小小于pageNum 所表示的位置，skip()会跳过所有元素，返回一个空列表。同样，如果pageSize大于resultList的大小，limit()也不会超出实际的元素数量。请注意，这种方法假设map中包含"pageNum "和"pageSize"这两个键，且对应的值都是有效的整数。在实际应用中，你需要进行错误检查，确保这些值是有效的，并处理可能出现的异常情况。：表示起始位置，通常是从1开始的，所以需要减1以得到实际的索引（数组/列表索引从0开始）。
List的Stream流操作
TechnicianWang的博客
12-06 1万+
1.过滤filter(T->boolean),保留boolean为true的元素。 list.stream().filter(user->user.getAge()>20).collect(Collectors.toList()) 保留年龄大于20的用户数据流，再将其转换为List。 2.去重distinct(),去除重复元素，这个方法是通过类的equals方法来判断两个元素是否相等，需要对原有元素重写equals方法。 list.strean().distinct()..
stream中的skip和limit进行分页操作
qq_42956376的博客
12-17 3157
skip的使用 skip(long n) 是一个跳过前 n 个元素的中间流操作。 以下skip代码案例： 集合中10个值，我们进行skip()跳过前5个元素，那么集合只会有从5开始往后的值 public static void main(String[] args) { List<Integer> list = new ArrayList<>(); for (int i = 1; i <=10 ; i++) { ..
Java8新特性Stream流之List、Map互转、去重、过滤
空空
11-17 2万+
一、Streams(流)？ java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如 java.util.Collection 的子类，List 或者 Set， Map 不支持。Stream 的操作可以串行执行或者并行执行。 二、具体使用 1.Filter(过滤) 过滤通过一个predicate接口
【055】java的List中使用filter过滤出符合特定条件的元素List
热门推荐
zhangchao19890805的专栏
12-26 14万+
在实际开发中，经常需要把一个列表中的元素，按照特定条件过滤出来，放到一个新的列表中。本文给出了几个例子，来描述解决这个问题的方法。 我们假设有一个书的List，需要找出其中id分别是3、6、8、9的书。 书的实体类： package blog.zhangchao.csdnBlog; /** * 书 * @author zhangchao * */ public class Bo
Java8特性Stream流的使用（学完就会，项目源码，附带个人总结）
09-09
以下将详细介绍Stream流的使用，以及它在Java8中的重要性。 首先，Stream API是一种用于处理集合的新接口，它可以对集合进行各种操作，如过滤、映射、聚合等，而无需显式地遍历集合。这种处理方式称为“函数式编程...
MarketDataOperation：使用Java（Stream）进行市场数据操作
02-12
虽然并行流能提升性能，但也需注意不必要的中间操作和内存消耗，合理使用`distinct()`、`sorted()`等可能导致全量排序或去重的操作，以及适当调整并行度。 10. **错误处理**： Stream API通常不抛出检查异常，...
stream流操作demo
01-14
在Java编程语言中，Stream API是Java 8引入的一个强大特性，它提供了处理集合...总的来说，Stream API极大地简化了Java中数据处理的代码，提高了可读性和效率。通过灵活运用流操作，我们可以更优雅地解决许多编程问题。
java代码-Java 8 stream的简单使用
07-15
在Java 8中，集合类如List、Set和Map都提供了stream()方法，可以直接从它们获取Stream对象。例如，`List<String> list = ...; list.stream();` 将创建一个基于list的Stream。 中间操作如filter()、map()和distinct...
Java8 使用 stream().filter()过滤List对象
qq_33240556的博客
01-10 1815
方法时，需要提供一个Lambda表达式作为参数，该表达式指定了过滤的条件。在上面的示例中，我们使用了一个简单的Lambda表达式。，表示只保留数字大于等于3的元素。可以根据具体的需求，使用不同的Lambda表达式来过滤不同的数据。在上面的代码中，我们首先创建了一个包含一些数字的List对象。方法将过滤后的元素收集到一个新的List对象中，并输出结果。方法将List对象转换为一个Stream对象，并使用。方法过滤出数字大于等于3的元素。在Java 8中，可以使用。需要注意的是，在使用。
List分页的几种方法
qq_41429436的博客
12-01 1万+
1.根据入参带分页参数进行sql查询分页 Criteria criteria = new Criteria(); //将dataAuto转成 factoryId brandId seriesId 等查询条件 String dataAuth = ""; TypeCaseHelper.dataAuto(criteria, dataAuth); // 设置分页信息 ExtPager pager = ne
stream().filter()过滤一个List对象，查找符合条件的对象集合
weixin_45939316的博客
04-02 1101
list.stream().filter(项->过滤内容).collect(Collectors.toList());;
Stream入门（4）----skip、limit、map、flatMap
qq_33304139的博客
10-02 586
skip() 用来做对List中元素的跳过，即如果为5，则跳过前5个元素，如果跳过元素超过list中元素个数，则返回一个空的list对象 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7, 7, 1); List<Integer> result=list; result = list.stream().skip(5).collect(toList()); .
Java8 List&amp；amp；amp；Map操作 stream ,filter ，map，forEach等功能
IT成长笔记
05-23 1514
List<Apple> appleList = new ArrayList<>();//存放apple对象集合 Apple apple1 = new Apple(1,"苹果1",new BigDecimal("3.25"),10); Apple apple12 = new Apple(1,"苹果2",new BigDecimal("1.3...
对于list集合进行分页处理
m0_51677119的博客
04-20 232
【代码】对于list集合进行分页处理。
Java8 使用list. stream().filter()过滤List对象（查找符合条件的对象集合），list.stream()根据某个属性排序，List进行分页处理，自定义分页工具类
Mou_O的博客
05-08 2928
简介： 本文主要说明在Java8及以上版本中，使用stream().filter()来过滤一个List对象，查找符合条件的对象集合。 List对象类（OnlineRegister） 测试数据： 使用filter()过滤List 此处是要通过一个id值获取符合这个id值的集合数据，此处的id值还不明确，所以测试的时候是写死的。然后再根据这个id值筛选出来的集合对象进行下一步筛选过滤，通过传入的参数进行筛选匹配符合的集合对象。 //1. 筛选当前子系统的数据 todo 带获取systemId
JDK8 常用的Stream流操作 方法
肥宅友的博客
06-18 2030
Stream流操作、Stream流map方法、Stream流排序、Stream流map和peek的区别、Stream流过滤filter、Stream创建集合、Stream和迭代器遍历集合。
java中stream流的常用方法
07-27
Java中Stream流的常用方法包括获取Stream流、中间方法和终结方法。 获取Stream流的方法有两种：集合获取Stream流和数组获取Stream流。集合获取Stream流可以使用集合类的stream()方法，例如Map的keySet()方法可以获取键流，values()方法可以获取值流，entrySet()方法可以获取键值对流。数组获取Stream流可以使用Arrays类的stream()方法，将数组转换为Stream流。 中间方法是对Stream流进行操作的方法，一次操作完毕之后，还可以继续进行其他操作。常用的中间方法包括filter()、map()、flatMap()、distinct()、sorted()、limit()和skip()等。filter()方法用于过滤元素，map()方法用于对元素进行映射，flatMap()方法用于扁平化处理，distinct()方法用于去重，sorted()方法用于排序，limit()方法用于限制元素数量，skip()方法用于跳过元素。 终结方法是Stream流的最后一个操作，一个Stream流只能有一个终结方法。常用的终结方法包括forEach()、collect()、count()、min()、max()、reduce()和toArray()等。forEach()方法用于遍历元素，collect()方法用于将元素收集到集合中，count()方法用于统计元素数量，min()方法用于获取最小值，max()方法用于获取最大值，reduce()方法用于对元素进行归约操作，toArray()方法用于将元素转换为数组。 综合应用Stream流的常用方法可以实现对数据的筛选、转换、排序、统计等操作，提高代码的简洁性和可读性。 #### 引用[.reference_title] - *1* *2* *3* [Java 基础进阶篇（十二）：Stream 流常用方法总结](https://blog.csdn.net/weixin_43819566/article/details/130537949)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

令人作呕的溏心蛋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值