Java Stream工具类操作使用
-
介绍
Java8的两个重大改变，一个是Lambda表达式，另一个就是本节要讲的Stream API表达式。Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作。
-
直接源码（目前只写了那么多，后面如果有其他小伙伴想写其他的，都可以。）
public class StreamUtils<T> { /** * 操作的集合 */ private Collection<T> collection; /** * 构造方法 * * @param collection 操作的集合 */ private StreamUtils(Collection<T> collection) { this.collection = collection; } /** * 获取StreamUtils * * @param collection 操作的集合 * @param <T> 泛型 * @return StreamUtils */ public static <T> StreamUtils<T> from(Collection<T> collection) { return new StreamUtils<>(collection); } /** * 封装Stream流filter方法 * * @param predicate 条件 * @return */ public StreamUtils<T> filter(Predicate<T> predicate) { collection = collection.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 = collection.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 collection.stream().collect(Collectors.toMap(keyMapper, valueMapper)); } /** * 对集合去重 * * @return */ public StreamUtils<T> distinct() { collection = collection.stream().distinct().collect(Collectors.toList()); return this; } /** * 取最大 * * @param comparator * @return */ public Optional<T> max(Comparator<T> comparator) { return collection.stream().max(comparator); } /** * 取最小 * * @param comparator * @return */ public Optional<T> min(Comparator<T> comparator) { return collection.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 collection.stream().filter(predicate).findFirst(); } /** * 查找第一个 * * @param predicate * @return */ public T findFirst(Predicate<T> predicate) { return collection.stream().filter(predicate).findFirst().orElse(null); } /** * 查找第一个 * * @return */ public T findFirst() { return collection.stream().findFirst().orElse(null); } /** * 查找第一个 * * @return */ public T getOne() { return collection.isEmpty() ? null : CollUtil.get(collection, 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) { collection.retainAll(other.collection); return this; } /** * 或者 * * @param other * @return */ public StreamUtils<T> or(StreamUtils<T> other) { other.collection.removeAll(collection); collection.addAll(other.collection); return this; } /** * 默认排序，升序 * * @param comparator * @return */ public StreamUtils<T> orderBy(Comparator<T> comparator) { collection = CollUtil.sort(collection, comparator); // collection.sort(comparator); return this; } /** * 排序，可指定排序方式 * * @param comparator 排序 * @param orderBy 1：降序，0：升序 * @return */ public StreamUtils<T> orderBy(Comparator<T> comparator, int orderBy) { if (1 == orderBy) { collection = CollUtil.sort(collection, comparator.reversed()); // collection.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) { collection = CollUtil.sort(collection, comparator.reversed()); // collection.sort(comparator.reversed()); } else { orderBy(comparator); } } return this; } /** * 降序排序 * * @param comparator * * @param condition 条件 * @return */ public StreamUtils<T> orderByDesc(Comparator<T> comparator) { collection = CollUtil.sort(collection, comparator.reversed()); return this; } /** * 降序排序 * * @param comparator * @return */ public StreamUtils<T> orderByDesc(boolean condition, Comparator<T> comparator) { if (condition) { collection = CollUtil.sort(collection, comparator.reversed()); } return this; } /** * 获取一个List * * @return */ public List<T> toList() { return new ArrayList<>(collection); } /** * 获取一个Set * * @return */ public Set<T> toSet() { return new HashSet<>(collection); } }生产环境已经用了几个月了，无翻车，朋友们，可以放心食用。
-
简单解释
-
其实还是受到了一些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}
]
看到这里，大家好觉得我强吗？觉得强的话，记得给个赞！不要着急，后面还有好多用法呢！
还有一个就是not and 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！
扫一扫
1062
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
