Stream流操作List集合一些常用方法封装

前言介绍（如果对你有帮助，请给我点点赞）

当我们在做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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果如下：

修改后的对象：TUser{id='1', name='坤哥'}
修改后的对象：TUser{id='2', name='坤哥'}
修改后的对象：TUser{id='3', name='坤哥'}
修改后的对象：TUser{id='4', name='坤哥'}

1
2
3
4
5

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 : 目标对象泛型
     * @param : 目标值泛型
     */
    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 : 目标对象泛型
     * @param : 目标值泛型
     * @param : 修改值泛型
     */
    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  泛型类型
     */
    public interface PropertySetter<T> {
        void set(T target, Object value);
    }

    /**
     * List -> List
     * 集合复制 【泛型可以不一样，但是泛型中的属性一样】
     * @param sourceList: 待赋值的集合
     * @param targetType: 泛型.class
     * @param 
     * @param 
     * @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 
     * @param 
     * @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 
     * @param 
     * @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 
     * @param 
     * @param 
     * @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 
     * @param 
     * @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