前言介绍（如果对你有帮助，请给我点点赞）
当我们在做Java项目时，经常需要对集合进行操作。而对于List集合来说，Stream流提供了一系列便捷的方法，可以帮助我们快速地完成集合的筛选、排序、聚合等操作。但是，由于Stream流的语法比较复杂，有时候会给我们带来一定的困扰。
为了解决这个问题，我在做项目的过程中，通过学习和总结，封装了一些常用的Stream流操作方法。这些方法可以让我们更加方便地对List集合进行处理，提高开发效率并减少出错的风险。
在下面的文档中，我将分享这些方法的实现思路和使用方法，希望能够对大家在日常开发中遇到的类似问题有所帮助
1、方法示例
【 批量修改集合对象的某个值 】
public static void main(String[] args) {
//创建假数据, 对象属性为 id , name
TUser u1 = new TUser("1","张三");
TUser u2 = new TUser("2","李四");
TUser u3 = new TUser("3","王五");
TUser u4 = new TUser("4","赵六");
List<TUser> userList = new ArrayList<>();
//将对象添加到集合中
userList.add(u1);userList.add(u2);userList.add(u3);userList.add(u4);
//TODO 引用【批量修改集合对象的某个值】，实现将集合中所有对象的name修改为 坤哥
//参数1：要处理的集合
//参数2：要修改的属性
//参数3：修改的值
setListObjectByProperty(userList,TUser::setName,"坤哥");
for (TUser tUser : userList) {
System.out.println("修改后的对象：" + tUser);
}
}
输出结果如下：
修改后的对象：TUser{id='1', name='坤哥'}
修改后的对象：TUser{id='2', name='坤哥'}
修改后的对象：TUser{id='3', name='坤哥'}
修改后的对象：TUser{id='4', name='坤哥'}
2、方法封装
import org.springframework.beans.BeanUtils;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class StreamUtils {
/**
* 批量修改集合对象的某个值
* @param list: 待修改集合
* @param consumer: 修改属性 泛型属性对象的set方法 Object::set方法
* @param val: 新值
* @param <T>: 目标对象泛型
* @param <V>: 目标值泛型
*/
public static <T,V> void setListObjectByProperty(List<T> list, BiConsumer<T,V> consumer, V val){
list.forEach(bean -> consumer.accept(bean,val));
}
/**
* 修改集合中满足条件的对象的指定属性的值
* @param list: 目标集合
* @param conditionProperty: 条件属性 Objecg::getFiled();
* @param conditionValue: 条件值
* @param consumer: 修改的属性 Objecg::setFiled();
* @param newValue: 修改值
* @param <T>: 目标对象泛型
* @param <V>: 目标值泛型
* @param <U>: 修改值泛型
*/
public static <T, V, U> void updateListObjByField(
List<T> list, Function<T, V> conditionProperty,
V conditionValue, BiConsumer<T, U> consumer, U newValue) {
list.stream()
.filter(element -> conditionProperty.apply(element).equals(conditionValue))
.forEach(element -> consumer.accept(element, newValue));
}
/**
* 泛型对象的属性setter接口
*
* @param <T> 泛型类型
*/
public interface PropertySetter<T> {
void set(T target, Object value);
}
/**
* List<SysUser> -> List<User>
* 集合复制 【泛型可以不一样，但是泛型中的属性一样】
* @param sourceList: 待赋值的集合
* @param targetType: 泛型.class
* @param <T>
* @param <R>
* @return
*/
public static <T, R> List<R> copyList(List<T> sourceList, Class<R> targetType){
return sourceList.stream()
.map( bean -> {
try {
R target = targetType.getDeclaredConstructor().newInstance();
BeanUtils.copyProperties(bean,target);
return target;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}).collect(Collectors.toList());
}
/**
* 根据指定条件过滤List集合中指定的元素信息
* @param inputList: 源list集合
* @param propertyExtractor: 指定对象过滤的属性 Object::getVal
* @param values: 过滤属性条件集合值
* @param <T>
* @param <R>
* @return
*/
public static <T, R> List<T> filterListByPropertyRemove(List<T> inputList, Function<T, R> propertyExtractor, List<R> values) {
Predicate<T> condition = item -> !values.contains(propertyExtractor.apply(item));
return filterList(inputList, condition);
}
public static <T> List<T> filterList(List<T> inputList, Predicate<T> condition) {
return inputList.stream()
.filter(condition)
.distinct()
.collect(Collectors.toList());
}
/**
*根据条件返回集合数据
* @param inputList: 源list集合
* @param propertyExtractor: 指定对象的属性 Object::getVal
* @param values: 属性条件集合值
* @param <T>
* @param <R>
* @return
*/
public <T, R> List<T> filterListByPropertyReturn(List<T> inputList, Function<T, R> propertyExtractor, List<R> values) {
return inputList.stream()
.filter(item -> values.contains(propertyExtractor.apply(item)))
.distinct()
.collect(Collectors.toList());
}
/**
* 【转Map】将集合中对象的属性作为key，val返回
* @param inputList: 目标list
* @param keyExtractor: key属性 Object:getObj
* @param valueExtractor: val属性 Object:getObj
* @param <T>
* @param <K>
* @param <V>
* @return
*/
public static <T, K, V> Map<K, V> extractPropertyToMap(List<T> inputList, Function<T, K> keyExtractor, Function<T, V> valueExtractor) {
return inputList.stream()
.collect(Collectors.toMap(keyExtractor, valueExtractor, (v1, v2) -> v2));
}
/**
* 【转Map】指定集合中对象的属性为key,对象本身为val返回
* @param inputList: 原集合
* @param keyExtractor: 作为key的属性 Object:getObj
* @param <T>
* @param <K>
* @return
*/
public <T, K> Map<K, T> extractPropertyToMap(List<T> inputList, Function<T, K> keyExtractor) {
return inputList.stream()
.collect(Collectors.toMap(keyExtractor, Function.identity(), (v1, v2) -> v2));
}
/**
* 将List<Object>集合按照某个属性进行分组
* @param inputList: 原集合
* @param keyExtractor: 分组的属性
* @param <T>
* @param <K>
* @return
*/
public static <T, K> Map<K, List<T>> groupByProperty(List<T> inputList, Function<T, K> keyExtractor) {
return inputList.stream()
.collect(Collectors.groupingBy(keyExtractor));
}
/**
* 获取集合中指定元素重复的数据,并返回这个元素的值
* @param list：源集合
* @param propertyExtractor: 指定元素 Object::getVal
* @param <T>
* @param <R>
* @return
*/
public static <T, R> List<R> findDuplicates(List<T> list, Function<T, R> propertyExtractor) {
Map<R, Long> propertyCountMap = list.stream()
.collect(Collectors.groupingBy(propertyExtractor, Collectors.counting()));
return propertyCountMap.entrySet().stream()
.filter(entry -> entry.getValue() > 1)
.map(Map.Entry::getKey)
.collect(Collectors.toList());
}
/**
* 提取List集合中对象的某个属性并返回集合
* @param inputList: 目标集合
* @param propertyExtractor: 泛型对象的属性 Object::getVal
* @param <T>
* @param <R>
* @return
*/
public static <T, R> List<R> extractPropertyToList(List<T> inputList, Function<T, R> propertyExtractor) {
return inputList.stream()
.map(propertyExtractor)
.collect(Collectors.toList());
}
/**
* 提取List集合中对象的某个属性
* @param inputList: 目标集合
* @param propertyExtractor: 泛型对象的属性 Object::getVal
* @param returnType: 返回集合指定泛型 String.class
* @param <T>
* @param <R>
* @return
*/
public static <T, R> List<R> extractPropertyToListWithType(List<T> inputList, Function<T, R> propertyExtractor, Class<R> returnType) {
return inputList.stream()
.map(propertyExtractor)
.collect(Collectors.toList());
}
/**
* 提取List集合中指定条件的属性值
* @param list：源集合
* @param filter：指定条件属性 泛型属性对象的get()方法
* @param mapper：返回属性 泛型属性对象的get()方法
* @param cls：返回类型
* @param value：条件值
* @param <T>
* @param <R>
* @return
*/
public static <T, R> List<R> extractPropertyToListWithTypeAndFilter(List<T> list, Function<T, String> filter, Function<T, R> mapper, Class<R> cls, String value) {
return list.stream()
.filter(obj -> filter.apply(obj).equals(value))
.map(mapper)
.collect(Collectors.toList());
}
/**
* 校验集合中对象指定属性的值是否都满足传入条件值
* @param collection: 源集合
* @param propertyAccessor: 指定属性 get方法
* @param expectedValue: 条件值
* @param <T>
* @param <E>
* @return
*/
public static <T, E> boolean validatePropertyAll(Collection<T> collection, Function<T, E> propertyAccessor, E expectedValue) {
return collection.stream().allMatch(item -> expectedValue.equals(propertyAccessor.apply(item)));
}
/**
* 校验集合中是否有一个对象的属性值满足传入条件值
* @param collection: 源集合
* @param propertyAccessor: 指定属性: 指定属性的 get方法
* @param expectedValue: 条件值
* @param <T>
* @param <E>
* @return
*/
public static <T, E> boolean validatePropertyAny(Collection<T> collection, Function<T, E> propertyAccessor, E expectedValue) {
return collection.stream().anyMatch(item -> expectedValue.equals(propertyAccessor.apply(item)));
}
/**
* List<String>集合正序排序
* @param list: 排序集合
*/
public static void sortPositive(List<String> list) {
Collections.sort(list);
}
/**
* List<String>集合倒序排序
* @param list: 排序集合
*/
public static void sortReverse(List<String> list) {
Collections.sort(list, Collections.reverseOrder());
}
/**
* List<T>集合正序排序
* @param list: 排序集合
* @param keyExtractor: 对象属性
* @param <T>
*/
public static <T, R extends Comparable<? super R>> void sortPositiveByField(List<T> list, Function<? super T, ? extends R> keyExtractor) {
Comparator<? super T> comparator = Comparator.comparing(keyExtractor);
Collections.sort(list, comparator);
}
/**
* List<T>集合倒序排序
* @param list: 排序集合
* @param keyExtractor: 对象属性
* @param <T>
* @param <R>
*/
public static <T, R extends Comparable<? super R>> void sortReverseByField(List<T> list, Function<? super T, ? extends R> keyExtractor) {
Comparator<? super T> comparator = Comparator.comparing(keyExtractor).reversed();
Collections.sort(list, comparator);
}
}