jdk7 模仿 lambda 的 list转map工具 ，list之间比对属性key 并赋值value的工具类

jdk7 由于不支持 lambda表达式，不能使用jdk8的Stream编程 ，在开发过程中遇到stream能够轻松解决的问题，也会比较绕。
看到网上有内部类替代lamdba 中一些箭头函数或者Function ,Consumer 的地方；

后面发现之前的做的集合工具类主要用的是范型， 并不是十分依赖lambda。

按jdk8定义了常用的两个接口

Function ,Consumer

public interface Function<T, R> {
    R apply(T t);
}

public interface BiConsumer<T, U> {
    void accept(T t, U u);
}

在定义工具方法的时候就可以，使用范型 +  Function、Consumer来定义

public class TestUtil {
 

/**
 * List 转换成新类型的List
 *
 * @param tList
 * @param transFunction
 * @return
 */
public static <T, S> List<S> transToTypeList(List<T> tList, Function<T, S> transFunction) {
    if (CollectionUtils.isEmpty(tList)) {
        return new ArrayList<>();
    }
    List<S> sList = new ArrayList<>();
    for (T t : tList) {
        if (t == null) {
            continue;
        }
        S s = transFunction.apply(t);
        if (s == null) {
            continue;
        }
        sList.add(s);
    }
    return sList;
}

  // 使用 

public static void main(String[] args) {
    List<String> aList = Arrays.asList("1", "2");
    //匿名内部类  使用idea 代码自动生成
    List<Integer>  bList = transToTypeList(aList, new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
            return Integer.valueOf(s);
        }
    });
    //或者采用先创建内部类对象，再调用; 可以通过抽取方法的方式从 匿名内部类的代码快速改写。
     List<Integer> cList = transToTypeList(aList, getIntegerFunction());
}

//内部类对象
private static Function<String, Integer> getIntegerFunction() {
    return new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
            return Integer.valueOf(s);
        }
    };
}
}

按照这个思路，把以前的工具类(对比集合中的属性值，并设置属性) BeanProperTySetUtil 改造成了 jdk7支持的

范型方法。

这个工具类，主要解决比如查询列表，查询出的某字段是code,这个时候需要比对字典列表数据，

并赋值到另一个属性上。也支持对原数据做操作后再赋值， 以及使用工具类将列表组装成树结构等。

// 设置属性的工具类 （用于设置字典名称，或者用户名等）
public class BeanPropertySetUtil {

    private static final Logger logger = LoggerFactory.getLogger(BeanPropertySetUtil.class);


    /**
     * 将源对象和目标对象通过指定的get方法获取key进行比较，
     * 比较相等时，将源对象的指定GET获取value，
     * 通过指定的Set方法设置到目标对象 的value
     * 例如 根据字典 getCode 和 年级 的getCode 匹配， 获取字典名称getName ,设置年级名称 setName;
     * T, S, U 分别表示 第一、二、三个类型
     *
     * @param sourceList
     * @param sourceGetKeyFunction
     * @param sourceGetValueFunction
     * @param targetList
     * @param targetGetKeyFunction
     * @param targetSetValueFunction
     * @param <T>                    源对象列表
     * @param <S>                    目标对象
     * @param <U>                    需要set的value
     */
    public static <T, S, U> void setPropertyFromSourceListToTarget(List<T> sourceList, Function<T, String> sourceGetKeyFunction, Function<T, U> sourceGetValueFunction,
                                                                   List<S> targetList, Function<S, String> targetGetKeyFunction, BiConsumer<S, U> targetSetValueFunction) {
        if (CollectionUtils.isEmpty(sourceList) || CollectionUtils.isEmpty(targetList)) {
            return;
        }
        Map<String, U> sourceMap = null;
        try {
            sourceMap = sourceList.stream()
                    .filter(sourse -> StringUtils.isNotEmpty(sourceGetKeyFunction.apply(sourse)))
                    .filter(sourse -> sourceGetValueFunction.apply(sourse) != null)
                    .collect(Collectors.toMap(sourceGetKeyFunction, sourceGetValueFunction, (newValue, oldValue) -> newValue));
        } catch (Exception e) {
            logger.info("将源数据列表转成map失败", e);
        }
        setPropertyFromSourceMapToTarget(sourceMap, targetList, targetGetKeyFunction, targetSetValueFunction);
    }

    /**
     * 按keyList进行匹配，然后赋值给List属性
     * T, S, U 分别表示 第一、二、三个类型
     *
     * @param sourceList
     * @param sourceGetKeyFunction
     * @param sourceGetValueFunction
     * @param targetList
     * @param targetGetKeyFunction
     * @param targetSetValueFunction
     * @param <T>                    源对象列表
     * @param <S>                    目标对象
     * @param <U>                    需要set的value
     */
    public static <T, S, U> void setListFromSourceListToTarget(List<T> sourceList, Function<T, String> sourceGetKeyFunction, Function<T, U> sourceGetValueFunction,
                                                               List<S> targetList, Function<S, List<String>> targetGetKeyFunction, BiConsumer<S, List<U>> targetSetValueFunction) {
        if (Co