Java仿造C#写了个LinqUtil，使用Lambda和泛型，对对象集合过滤filter筛选和取属性map还有去重，供大家参考使用

package org.jeecg.common.util;

import lombok.var;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class LinqUtil {
    /**
     * 泛型测试-取数组第一位
     */
    public static <T> T first(List<T> list) {
        if (list.size() == 0)
            return null;
        return list.get(0);
    }

    /**
     * 筛选元素（数组）
     * 例: var items = LambdaUtil.filter(items, m -> m.getName() == "test");
     */
    public static <T> List<T> filter(List<T> items, Predicate<? super T> filterExpression) {
        return items.stream().filter(filterExpression).collect(Collectors.toList());
    }

    /**
     * 筛选元素，取第一个
     * 例: var item = LambdaUtil.filterOne(items, m -> m.getId() == 100);
     */
    public static <T> T filterOne(List<T> items, Predicate<? super T> filterExpression) {
        return first(filter(items, filterExpression));
    }

    /**
     * 筛选元素，取第一个
     * 例: var item = LambdaUtil.filterOne(items, m -> m.getId() == 100);
     */
    public static <T> T filterOne(T[] items, Predicate<? super T> filterExpression) {
        return filterOne(ArrayUtil.arrayToList(items), filterExpression);
    }

    /***
     * 筛选属性（数组）
     * 例: var ids = LambdaUtil.map(items, Item::getId);
     */
    public static <T, R> List<R> map(List<T> items, Function<? super T, ? extends R> mapExpression) {
        if (null == items)
            return null;
        List<R> list = items.stream().map(mapExpression).collect(Collectors.toList());
        while (list.contains(null))
            list.remove(null);
        return list;
    }

    /**
     * 筛选属性，取第一个
     * 例: var id = LambdaUtil.mapOne(items, Item::getId);
     */
    public static <T, R> R mapOne(List<T> items, Function<? super T, ? extends R> mapExpression) {
        return first(map(items, mapExpression));
    }

    /***
     * 根据属性去重
     * 例: items = LambdaUtil.distinctByProperty(items, Item::getId);
     */
    public static <T, R> List<T> distinctByProperty(List<T> items, Function<? super T, ? extends R> mapExpression) {
        var seen = new ConcurrentHashMap<R, Boolean>();
        return items.stream().filter(m -> seen.putIfAbsent(mapExpression.apply(m), Boolean.TRUE) == null).collect(Collectors.toList());
    }

    public static <T> List<T> combine(List<T> list1, List<T> list2) {
        var list = new ArrayList<T>();
        if (list1 != null)
            list.addAll(list1);
        if (list2 != null)
            list.addAll(list2);
        return list;
    }
}