Java 自定义StreamUtils工具类，生产力max，后端程序员必看。

Java Stream工具类操作使用

1. 介绍

   Java8的两个重大改变，一个是Lambda表达式，另一个就是本节要讲的Stream API表达式。Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作。

2. 直接源码（目前只写了那么多，后面如果有其他小伙伴想写其他的，都可以。）

   public class StreamUtils<T> {
   
       /**
        * 操作的集合
        */
       private List<T> list;
   
       /**
        * 构造方法
        *
        * @param list 操作的集合
        */
       private StreamUtils(List<T> list) {
           this.list = list;
       }
   
       /**
        * 获取StreamUtils
        *
        * @param list 操作的集合
        * @param <T>  泛型
        * @return StreamUtils
        */
       public static <T> StreamUtils<T> from(List<T> list) {
           return new StreamUtils<>(list);
       }
   
       /**
        * 封装Stream流filter方法
        *
        * @param predicate 条件
        * @return
        */
       public StreamUtils<T> filter(Predicate<T> predicate) {
           list = list.stream().filter(predicate).collect(Collectors.toList());
           return this;
       }
   
       /**
        * 取出某个属性的值
        *
        * @param mapper
        * @param <R>
        * @return
        */
       public <R> StreamUtils<R> map(Function<T, R> mapper) {
           List<R> result = list.stream().map(mapper).collect(Collectors.toList());
           return new StreamUtils<>(result);
       }
   
       /**
        * 集合转到map中，以对象其中的一个属性为key
        *
        * @param keyMapper
        * @param valueMapper
        * @return
        */
       public Map<T, T> toMap(Function<T, T> keyMapper, Function<T, T> valueMapper) {
           return list.stream().collect(Collectors.toMap(keyMapper, valueMapper));
       }
   
       /**
        * 对集合去重
        *
        * @return
        */
       public StreamUtils<T> distinct() {
           list = list.stream().distinct().collect(Collectors.toList());
           return this;
       }
   
       /**
        * 取最大
        *
        * @param comparator
        * @return
        */
       public Optional<T> max(Comparator<T> comparator) {
           return list.stream().max(comparator);
       }
   
       /**
        * 取最小
        *
        * @param comparator
        * @return
        */
       public Optional<T> min(Comparator<T> comparator) {
           return list.stream().min(comparator);
       }
   
       /**
        * 等于
        *
        * @param keyExtractor
        * @param value
        * @return
        */
       public StreamUtils<T> eq(Function<T, Object> keyExtractor, Object value) {
           return filter(obj -> Objects.equals(keyExtractor.apply(obj), value));
       }
   
       /**
        * 等于
        *
        * @param condition 判断是否参与查询的条件
        * @param keyExtractor
        * @param value
        * @return
        */
       public StreamUtils<T> eq(boolean condition, Function<T, Object> keyExtractor, Object value) {
           return condition ? filter(obj -> Objects.equals(keyExtractor.apply(obj), value)) : this;
       }
   
       /**
        * 是否为null
        *
        * @return
        */
       public StreamUtils<T> isNull(Function<T, Object> keyExtractor) {
           return filter(obj -> Objects.isNull(keyExtractor.apply(obj)));
       }
   
       /**
        * 是否为null
        *
        * @param condition 判断是否参与查询的条件
        * @return
        */
       public StreamUtils<T> isNull(boolean condition, Function<T, Object> keyExtractor) {
           return condition ? filter(obj -> Objects.isNull(keyExtractor.apply(obj))) : this;
       }
   
       /**
        * 是否为空
        *
        * @return
        */
       public StreamUtils<T> isEmpty(Function<T, Object> keyExtractor) {
           return filter(obj -> ObjectUtil.isEmpty(keyExtractor.apply(obj)));
       }
   
       /**
        * 是否为空
        *
        * @param condition 判断是否参与查询的条件
        * @return
        */
       public StreamUtils<T> isEmpty(boolean condition, Function<T, Object> keyExtractor) {
           return condition ? filter(obj -> ObjectUtil.isEmpty(keyExtractor.apply(obj))) : this;
       }
   
       /**
        * 是否不为null
        *
        * @return
        */
       public StreamUtils<T> isNotNull(Function<T, Object> keyExtractor) {
           return filter(obj -> Objects.nonNull(keyExtractor.apply(obj)));
       }
   
       /**
        * 是否不为null
        *
        * @param condition 判断是否参与查询的条件
        * @return
        */
       public StreamUtils<T> isNotNull(boolean condition, Function<T, Object> keyExtractor) {
           return condition ? filter(obj -> Objects.nonNull(keyExtractor.apply(obj))) : this;
       }
   
       /**
        * 是否不为空
        *
        * @return
        */
       public StreamUtils<T> isNotEmpty(Function<T, Object> keyExtractor) {
           return filter(obj -> ObjectUtil.isNotEmpty(keyExtractor.apply(obj)));
       }
   
       /**
        * 是否不为空
        *
        * @param condition 判断是否参与查询的条件
        * @return
        */
       public StreamUtils<T> isNotEmpty(boolean condition, Function<T, Object> keyExtractor) {
           return condition ? filter(obj -> ObjectUtil.isNotEmpty(keyExtractor.apply(obj))) : this;
       }
   
       /**
        * 不等于
        *
        * @param keyExtractor
        * @param value
        * @return
        */
       public StreamUtils<T> ne(Function<T, Object> keyExtractor, Object value) {
           return filter(obj -> !Objects.equals(keyExtractor.apply(obj), value));
       }
   
       /**
        * 不等于
        *
        * @param condition 判断是否参与查询的条件
        * @param keyExtractor
        * @param value
        * @return
        */
       public StreamUtils<T> ne(boolean condition, Function<T, Object> keyExtractor, Object value) {
           return condition ? filter(obj -> !Objects.equals(keyExtractor.apply(obj), value)) : this;
       }
   
       /**
        * 大于等于
        *
        * @param keyExtractor
        * @param threshold
        * @return
        */
       public <U extends Comparable<U>> StreamUtils<T> ge(Function<T, U> keyExtractor, U threshold) {
           return filter(obj -> {
               U value = keyExtractor.apply(obj);
               return null != value && value.compareTo(threshold) >= 0;
           });
       }
   
       /**
        * 大于等于
        *
        * @param condition 判断是否参与查询的条件
        * @param keyExtractor
        * @param threshold
        * @return
        */
       public <U extends Comparable<U>> StreamUtils<T> ge(boolean condition, Function<T, U> keyExtractor, U threshold) {
           return condition ? filter(obj -> {
               U value = keyExtractor.apply(obj);
               return null != value && value.compareTo(threshold) >= 0;
           }) : this;
       }
   
       /**
        * 大于
        *
        * @param keyExtractor
        * @param threshold
        * @return
        */
       public <U extends Comparable<U>> StreamUtils<T> gt(Function<T, U> keyExtractor, U threshold) {
           // return filter(obj -> keyExtractor.apply(obj).compareTo(threshold) > 0);
           return filter(obj -> {
               U value = keyExtractor.apply(obj);
               return value != null && value.compareTo(threshold) > 0;
           });
       }
   
       /**
        * 大于
        *
        * @param condition 判断是否参与查询的条件
        * @param keyExtractor
        * @param threshold
        * @return
        */
       public <U extends Comparable<U>> StreamUtils<T> gt(boolean condition, Function<T, U> keyExtractor, U threshold) {
           return condition ? filter(obj -> {
               U value = keyExtractor.apply(obj);
               return null != value && value.compareTo(threshold) > 0;
           }) : this;
       }
   
       /**
        * 小于等于
        *
        * @param keyExtractor
        * @param threshold
        * @return
        */
       public <U extends Comparable<U>> StreamUtils<T> le(Function<T, U> keyExtractor, U threshold) {
           return filter(obj -> {
               U value = keyExtractor.apply(obj);
               return null != value && value.compareTo(threshold) <= 0;
           });
       }
   
       /**
        * 小于等于
        *
        * @param condition 判断是否参与查询的条件
        * @param keyExtractor
        * @param threshold
        * @return
        */
       public <U extends Comparable<U>> StreamUtils<T> le(boolean condition, Function<T, U> keyExtractor, U threshold) {
           return condition ? filter(obj -> {
               U value = keyExtractor.apply(obj);
               return null != value && value.compareTo(threshold) <= 0;
           }) : this;
       }
   
       /**
        * 小于
        *
        * @param keyExtractor
        * @param threshold
        * @return
        */
       public <U extends Comparable<U>> StreamUtils<T> lt(Function<T, U> keyExtractor, U threshold) {
           // return filter(obj -> keyExtractor.apply(obj).compareTo(threshold) < 0);
           return filter( obj -> {
               U value = keyExtractor.apply(obj);
               return value != null && value.compareTo(threshold) < 0;
           });
       }
   
       /**
        * 小于
        *
        * @param condition 判断是否参与查询的条件
        * @param keyExtractor
        * @param threshold
        * @return
        */
       public <U extends Comparable<U>> StreamUtils<T> lt(boolean condition, Function<T, U> keyExtractor, U threshold) {
           return condition ? filter(obj -> {
               U value = keyExtractor.apply(obj);
               return value != null && value.compareTo(threshold) < 0;
           }) : this;
       }
   
       /**
        * 模糊查询：%like%
        *
        * @param keyExtractor
        * @param pattern
        * @return
        */
       public StreamUtils<T> like(Function<T, String> keyExtractor, String pattern) {
           return filter(obj -> {
               String fieldValue = keyExtractor.apply(obj);
               return fieldValue != null && fieldValue.contains(pattern);
           });
       }
   
       /**
        * 模糊查询：%like%
        * @param condition 判断是否参与查询的条件
        * @param keyExtractor
        * @param pattern
        * @return
        */
       public StreamUtils<T> like(boolean condition, Function<T, String> keyExtractor, String pattern) {
           return condition ? filter(obj -> {
               String fieldValue = keyExtractor.apply(obj);
               return fieldValue != null && fieldValue.contains(pattern);
           }) : this;
       }
   
       /**
        * in：包含
        *
        * @param keyExtractor
        * @param values
        * @return
        */
       public StreamUtils<T> in(Function<T, Object> keyExtractor, Collection<?> values) {
           return filter(obj -> {
               Object fieldValue = keyExtractor.apply(obj);
               return CollUtil.isNotEmpty(values) && values.contains(fieldValue);
           });
       }
   
       /**
        * in：包含
        *
        * @param condition 判断是否参与查询的条件
        * @param keyExtractor
        * @param values
        * @return
        */
       public StreamUtils<T> in(boolean condition, Function<T, Object> keyExtractor, Collection<?> values) {
           return condition ? filter(obj ->
           {Object fieldValue = keyExtractor.apply(obj);
               return CollUtil.isNotEmpty(values) && values.contains(fieldValue);}) : this;
       }
   
       /**
        * notIn：不包含
        *
        * @param keyExtractor
        * @param values
        * @return
        */
       public StreamUtils<T> notIn(Function<T, Object> keyExtractor, Collection<?> values) {
           return filter(obj -> {
               Object fieldValue = keyExtractor.apply(obj);
               return !(CollUtil.isNotEmpty(values) && values.contains(fieldValue));
           });
       }
   
       /**
        * notIn：不包含
        *
        * @param condition 判断是否参与查询的条件
        * @param keyExtractor
        * @param values
        * @return
        */
       public StreamUtils<T> notIn(boolean condition, Function<T, Object> keyExtractor, Collection<?> values) {
           return condition ? filter(obj -> {
               Object fieldValue = keyExtractor.apply(obj);
               return !(CollUtil.isNotEmpty(values) && values.contains(fieldValue));
           }) : this;
       }
   
       /**
        * 查找一个
        *
        * @param predicate
        * @return
        */
       public Optional<T> getOne(Predicate<T> predicate) {
           return list.stream().filter(predicate).findFirst();
       }
   
       /**
        * 查找第一个
        *
        * @param predicate
        * @return
        */
       public T findFirst(Predicate<T> predicate) {
           return list.stream().filter(predicate).findFirst().orElse(null);
       }
   
       /**
        * 查找第一个
        *
        * @return
        */
       public T findFirst() {
           return list.stream().findFirst().orElse(null);
       }
   
       /**
        * 查找第一个
        *
        * @return
        */
       public T getOne() {
           return list.isEmpty() ? null : list.get(0);
       }
   
       /**
        * not取反操作，
        *
        * @param predicate
        * @return
        */
       public StreamUtils<T> not(Predicate<T> predicate) {
           return filter(predicate.negate());
       }
   
       /**
        * 并且 and连接符
        *
        * @param other
        * @return
        */
       public StreamUtils<T> and(StreamUtils<T> other) {
           list.retainAll(other.list);
           return this;
       }
   
       /**
        * 或者
        *
        * @param other
        * @return
        */
       public StreamUtils<T> or(StreamUtils<T> other) {
           other.list.removeAll(list);
           list.addAll(other.list);
           return this;
       }
   
       /**
        * 默认排序，升序
        *
        * @param comparator
        * @return
        */
       public StreamUtils<T> orderBy(Comparator<T> comparator) {
           list.sort(comparator);
           return this;
       }
   
       /**
        * 排序，可指定排序方式
        *
        * @param comparator 排序
        * @param orderBy    1：降序，0：升序
        * @return
        */
       public StreamUtils<T> orderBy(Comparator<T> comparator, int orderBy) {
           if (1 == orderBy) {
               list.sort(comparator.reversed());
           } else {
               orderBy(comparator);
           }
           return this;
       }
   
       /**
        * 排序，可指定排序方式，可以指定条件，条件为true时才执行排序
        *
        * @param comparator 排序
        * @param condition 条件
        * @param orderBy    1：降序，0：升序
        * @return
        */
       public StreamUtils<T> orderBy(boolean condition, Comparator<T> comparator, int orderBy) {
           if (condition) {
               if (1 == orderBy) {
                   list.sort(comparator.reversed());
               } else {
                   orderBy(comparator);
               }
           }
           return this;
       }
   
       /**
        * 获取一个List
        *
        * @return
        */
       public List<T> toList() {
           return list;
       }
   }
   

   生产环境已经用了几个月了，无翻车，朋友们，可以放心食用。

3. 简单解释

   • 其实还是受到了一些mybatis plus的一些启发的，在这里，鸣谢致敬：@baomidou，@chatgpt，主要是用了MP(mybaits-plus，后面都用这个简称)，比如一些eq，ne，ge，le这些方法的命名啥的，都是跟着它来的，也是非常喜欢MP的一个lamdba写法，所以才想出了要写个StreamUtils工具类，效仿一下MP的使用，对List集合进行操作。下面我们来看看具体哪些用法，还有我比较常用的。

     上面工具类中写了很多的方法对吧，什么eq，ne，啥啥啥的，其实啊，也都是源自一个java 8的Stream的方法，那就是filter方法，包括没有这个工具类之前，我也都是用这个方法筛选集合，怎么说呢，其实也是比较方便了，最起码比你自己for循环好多了，但是人嘛，都是这样，没有最，只有更。懒惰才是科技第一生产力，手动狗头。所以就有了这个工具类的诞生。

   • 简单常用方法使用举例，和解释。

     • 先来看看所有筛选方法的老祖宗。

           /**
            * 封装Stream流filter方法
            *
            * @param predicate 条件
            * @return
            */
           public StreamUtils<T> filter(Predicate<T> predicate) {
               list = list.stream().filter(predicate).collect(Collectors.toList());
               return this;
           }
       // 这里就是简单的调用stream的filter方法，只不过，方法参数的这个条件，是自己定义的，也就是自己写条件。基本上和自己用filter差不多。不过后面会在不同的方法中做不同的操作。
       

     • 我们先来看看eq方法，也就是等于

       /**
            * 等于
            *
            * @param keyExtractor
            * @param value
            * @return
            */
           public StreamUtils<T> eq(Function<T, Object> keyExtractor, Object value) {
               return filter(obj -> Objects.equals(keyExtractor.apply(obj), value));
           }
       
           /**
            * 等于
            *
            * @param condition 判断是否参与查询的条件
            * @param keyExtractor
            * @param value
            * @return
            */
           public StreamUtils<T> eq(boolean condition, Function<T, Object> keyExtractor, Object value) {
               return condition ? filter(obj -> Objects.equals(keyExtractor.apply(obj), value)) : this;
           }
       // 这个效仿MP，基本上每个筛选的方法都有重载的方法，会多一个condition条件参数，用于筛选前的判断操作，类似于mybatis的If标签。后面会演示condition的作用。可以看到，这个eq方法就是调用了前面的filter方法，传的条件中，写死了用equals比较，这里使用了java.util包下的Objects类的equals方法，是比较安全的方法，即使第一个参数有空也不会NP。
       

       • 我们来看看实践

         自定义一个专门用来测试的类

         /**
          * @author GmDsg
          * @date 2023/8/14 11:21
          * @description TODO
          */
         @Data
         public class TestCls {
             
             
             private String name;
             
             private Integer num;
             
             private BigDecimal amount;
         }
         

                 // eq实践
                 List<TestCls> testClsList = new ArrayList<>();
                 for (int i = 0; i < 10; i++) {
                     testClsList.add(new TestCls("mingcheng" + i, i, NumberUtil.mul(10, new BigDecimal(i))));
                 }
                 // 筛选name = mingcheng1的元素
                 List<TestCls> mingcheng1 = StreamUtils
                         .from(testClsList)
                         .eq(TestCls::getName, "mingcheng1")
                         .toList();
         
         // 结果：[TestCls(name=mingcheng1, num=1, amount=10)]
         

         重载方法，带condition参数用法

                 List<TestCls> testClsList = new ArrayList<>();
                 for (int i = 0; i < 10; i++) {
                     testClsList.add(new TestCls("mingcheng" + i, i, NumberUtil.mul(10, new BigDecimal(i))));
                 }        
         		// 重载方法condition参数用法
                 List<TestCls> mingcheng1 = StreamUtils
                         .from(testClsList)
                         .eq(CollUtil.isNotEmpty(testClsList), TestCls::getName, "mingcheng1")
                         .toList();
                 System.out.println(mingcheng1);
         // 加了个条件，只有testClsList不为空的情况才会按照name筛选，否则不筛选。
         // 结果：[TestCls(name=mingcheng1, num=1, amount=10)]和上面一样。
         

         那我们直接用false试试。

                 List<TestCls> testClsList = new ArrayList<>();
                 for (int i = 0; i < 10; i++) {
                     testClsList.add(new TestCls("mingcheng" + i, i, NumberUtil.mul(10, new BigDecimal(i))));
                 }        
         		// 重载方法condition参数用法
                 List<TestCls> mingcheng1 = StreamUtils
                         .from(testClsList)
                         .eq(false, TestCls::getName, "mingcheng1")
                         .toList();
                 System.out.println(JSONUtil.toJsonStr(mingcheng1));
         
         

         结果：

         [
          {"name":"mingcheng0","num":0,"amount":0},
          {"name":"mingcheng1","num":1,"amount":10},
          {"name":"mingcheng2","num":2,"amount":20},
          {"name":"mingcheng3","num":3,"amount":30},
          {"name":"mingcheng4","num":4,"amount":40},
          {"name":"mingcheng5","num":5,"amount":50},
          {"name":"mingcheng6","num":6,"amount":60},
          {"name":"mingcheng7","num":7,"amount":70},
          {"name":"mingcheng8","num":8,"amount":80},
          {"name":"mingcheng9","num":9,"amount":90}
         ]
         // 可以看到，如果前置条件的condition为flase时，则不会执行条件筛选。
         

         再来看看不等于条件筛选

         		// 反之，筛选name != mingcheng1的元素        
         		List<TestCls> mingchengbdy1 = StreamUtils
                         .from(testClsList)
                         .ne(TestCls::getName, "mingcheng1")
                         .toList();
                 System.out.println(JSONUtil.toJsonStr(mingchengbdy1));
         

         结果：

         [
             {"name":"mingcheng0","num":0,"amount":0},
             {"name":"mingcheng2","num":2,"amount":20},
             {"name":"mingcheng3","num":3,"amount":30},
             {"name":"mingcheng4","num":4,"amount":40},
             {"name":"mingcheng5","num":5,"amount":50},
             {"name":"mingcheng6","num":6,"amount":60},
             {"name":"mingcheng7","num":7,"amount":70},
             {"name":"mingcheng8","num":8,"amount":80},
             {"name":"mingcheng9","num":9,"amount":90}
         ]
         // 把“mingcheng1”的元素筛选掉了。
         

         • 这个也是有condition条件的方法，就不一一举例了，用法都一样。包括什么大于，小于，源码中方法都有注释，可以自行尝试。

         大于，小于，大于等于等方法

                 // 筛选amount大于等于50的元素
         		List<TestCls> geAmount = StreamUtils
                         .from(testClsList)
                         .ge(TestCls::getAmount, new BigDecimal("50"))
                         .toList();
                 System.out.println(JSONUtil.toJsonStr(geAmount));
         

         结果：

         [
             {"name":"mingcheng5","num":5,"amount":50},
             {"name":"mingcheng6","num":6,"amount":60},
             {"name":"mingcheng7","num":7,"amount":70},
             {"name":"mingcheng8","num":8,"amount":80},
             {"name":"mingcheng9","num":9,"amount":90}
         ]
         // 筛选成功。
         

         试一试排序，降序排序，升序降序都可以。

             /**
              * 默认排序，升序
              *
              * @param comparator
              * @return
              */
             public StreamUtils<T> orderBy(Comparator<T> comparator) {
                 list.sort(comparator);
                 return this;
             }
         
             /**
              * 排序，可指定排序方式
              *
              * @param comparator 排序
              * @param orderBy    1：降序，0：升序
              * @return
              */
             public StreamUtils<T> orderBy(Comparator<T> comparator, int orderBy) {
                 if (1 == orderBy) {
                     list.sort(comparator.reversed());
                 } else {
                     orderBy(comparator);
                 }
                 return this;
             }
         

         来一个降序排序

                 // 筛选amount大于等于50的元素，并且安排amount降序排序
                 List<TestCls> geAmount = StreamUtils
                         .from(testClsList)
                         .ge(TestCls::getAmount, new BigDecimal("50"))
                         .orderBy(Comparator.comparing(TestCls::getAmount), 1)
                         .toList();
                 System.out.println(JSONUtil.toJsonStr(geAmount));
         

         结果：

         [
             {"name":"mingcheng9","num":9,"amount":90},
             {"name":"mingcheng8","num":8,"amount":80},
             {"name":"mingcheng7","num":7,"amount":70},
             {"name":"mingcheng6","num":6,"amount":60},
             {"name":"mingcheng5","num":5,"amount":50}
         ]
         

         排序成功。

   上面的都是获取返回一个集合，也有返回单个的方法，例如MP的getOne方法。工具类中有findFirst和getOne，其实都差不多，用哪个都可以，也可以用max和min方法，取最大的一个或者最小的一个。

           // findFirst
           TestCls geAmountMax = StreamUtils
                   .from(testClsList)
                   .ge(TestCls::getAmount, new BigDecimal("50"))
                   .orderBy(Comparator.comparing(TestCls::getAmount), 1)
                   .findFirst();
           System.out.println(JSONUtil.toJsonStr(geAmountMax));
   

   其实这个就是查最大的一个，后面也有max方法代替。

​ 结果：

{"name":"mingcheng9","num":9,"amount":90}

max方法

        // max方法
        TestCls geAmountMax = StreamUtils
                .from(testClsList)
                .max(Comparator.comparing(TestCls::getAmount, Comparator.nullsFirst(BigDecimal::compareTo))) // 最好加上Comparator.nullsFirst(BigDecimal::compareTo)，防止空指针异常。
                .orElse(null);
        System.out.println(JSONUtil.toJsonStr(geAmountMax));

结果：

{"name":"mingcheng9","num":9,"amount":90}

结果是一样的。

此外我还写了isNull，isNotNull，isEmpty，isNotEmpty，可用来筛选为null，或者为空的元素。

演示一个isNotEmpty的用法，其余的用法一致。

        List<TestCls> testClsList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                testClsList.add(new TestCls("", i, NumberUtil.mul(10, new BigDecimal(i))));
            } else {
                testClsList.add(new TestCls("mingcheng" + i, i, NumberUtil.mul(10, new BigDecimal(i))));
            }
        }
// 循环语句更改，如果是 i 被2整除，则设置该元素的name字段为空字符串。

调用isNotEmpty方法筛选元素

        // 筛选出name不为空串的元素
        List<TestCls> notEmptyList = StreamUtils
                .from(testClsList)
                .isNotEmpty(TestCls::getName)
                .toList();
        System.out.println(JSONUtil.toJsonStr(notEmptyList));

结果：

[
    {"name":"mingcheng1","num":1,"amount":10},
    {"name":"mingcheng3","num":3,"amount":30},
    {"name":"mingcheng5","num":5,"amount":50},
    {"name":"mingcheng7","num":7,"amount":70},
    {"name":"mingcheng9","num":9,"amount":90}
]

筛选成功。

反之筛选name为空的元素

        // 筛选出name为空串的元素
        List<TestCls> notEmptyList = StreamUtils
                .from(testClsList)
                .isEmpty(TestCls::getName)
                .toList();
        System.out.println(JSONUtil.toJsonStr(notEmptyList));

结果：

[
    {"name":"","num":0,"amount":0},
    {"name":"","num":2,"amount":20},
    {"name":"","num":4,"amount":40},
    {"name":"","num":6,"amount":60},
    {"name":"","num":8,"amount":80}
]

看到这里，大家好觉得我强吗？觉得强的话，记得给个赞！不要着急，后面还有好多用法呢！

还有一个就是or 和 and的用法，and目前没用过生产，or用了生产，无翻车。

        // 筛选出name不为空，或者amount大于等于50的元素
        List<TestCls> orList = StreamUtils
                .from(testClsList)
                .isNotEmpty(TestCls::getName)
                .or(StreamUtils.from(testClsList)
                        .ge(TestCls::getAmount, new BigDecimal("50")))
                .toList();

结果：

[
    {"name":"mingcheng1","num":1,"amount":10},
    {"name":"mingcheng3","num":3,"amount":30},
    {"name":"mingcheng5","num":5,"amount":50},
    {"name":"mingcheng7","num":7,"amount":70},
    {"name":"mingcheng9","num":9,"amount":90},
    {"name":"","num":6,"amount":60},
    {"name":"","num":8,"amount":80}
]

可以非常好，没让我失望。

同样的我们再用个and来试试。

        // 筛选出name不为空并且amount大于等于50的元素
        List<TestCls> andList = StreamUtils
                .from(testClsList)
                .isNotEmpty(TestCls::getName)
                .and(StreamUtils.from(testClsList)
                        .ge(TestCls::getAmount, new BigDecimal("50")))
                .toList();
        System.out.println(JSONUtil.toJsonStr(andList));

结果：

[
    {"name":"mingcheng5","num":5,"amount":50},
    {"name":"mingcheng7","num":7,"amount":70},
    {"name":"mingcheng9","num":9,"amount":90}
]

好帅一个！

in 和 notIn方法，类似于SQL语句中的用法，包含，不包含。

        List<Integer> list = Arrays.asList(76, 5445, 776, 243, 7, 88, 98, 35, 5234, 56, 324, 54);

        // notIn
        List<Integer> list2 = StreamUtils
                .from(list)
                .notIn(s -> s, Arrays.asList(88, 98, 35, 5234))
                .toList();
        System.out.println(list2);

结果：

[76, 5445, 776, 243, 7, 56, 324, 54]

in方法使用

        // in
        List<Integer> list3 = StreamUtils
                .from(list)
                .in(s -> s, Arrays.asList(88, 98, 35, 5234))
                .toList();
        System.out.println(list3);

结果：

[88, 98, 35, 5234]

还有准备写最后一个，map方法，就是取某个属性的属性值，另外返回一个集合，比如，取集合中所有的amount字段，结果就会获取

一个List的集合。

        // map方法获取amount属性
        List<BigDecimal> mapList = StreamUtils
                .from(testClsList)
                .map(TestCls::getAmount)
                .toList();
        System.out.println(mapList);

结果：

[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

到这里，这个StreamUtils工具类就写的差不多了，我的天哪，真累啊，写文档不是啥好活儿，不过只要能帮助到大家，我就知足了。如果后面大家又更好的想法，也可以自行补充到这个类中，也可以给我留言，让我也学习学习，加到里面，然后我们一起快乐的coding！