Oqv拜客生活常识网

userList.stream().limit(2).forEach(user -> System.out.println("姓名：" + user.getName()));
 

6.最大值最小值Oqv拜客生活常识网

Oqv拜客生活常识网

 int maxAge = userList.stream().mapToInt(User::getAge).max().getAsInt();
 int minAge = userList.stream().mapToInt(User::getAge).min().getAsInt();

Oqv拜客生活常识网

封装的Stream使用类，可以直接拿走使用：

Oqv拜客生活常识网

public class StreamUtils {
    /**
     * 集合为空，创建空的Stream流；否则创建集合的Stream流
     * 避免出现空指针
     *
     * @param collection 集合
     * @param    集合元素的泛型
     * @return Stream对象
     */
    private static  Stream streamOf(Collection collection) {
        return CollectionUtils.isEmpty(collection) ? Stream.empty() : collection.stream();
    }

    /**
     * 按照映射规则映射成一个新的集合流
     *
     * @param list  集合
     * @param mapper   集合属性元素
     * @param    函数输入类型的泛型
     * @param    函数结果类型的泛型
     * @return  新的集合
     */
    public static  List mapList(List list, Function<? super T, ? extends R> mapper) {
        return streamOf(list).map(mapper).collect(Collectors.toList());
    }

    /**
     * 根据给定的条件进行筛选，将符合条件的元素提取成新的流
     *
     * @param list          集合
     * @param predicate     筛选规则
     * @param            流元素的类型
     * @return  符合条件的流集合
     */
    public static  List filter(List list, Predicate<? super T> predicate) {
        return streamOf(list).filter(predicate).collect(Collectors.toList());
    }

    /**
     * 根据给定的条件进行筛选，将符合条件的元素提取成新的流
     *
     * @param list          集合
     * @param predicates    多个筛选条件
     * @param            流元素的类型
     * @return 符合条件的流集合
     */
    @SafeVarargs
    public static  List filters(List list, Predicate<? super T> ... predicates) {
        Stream stream = streamOf(list);
        for (Predicate<? super T> predicate : predicates) {
            stream = stream.filter(predicate);
        }
        return stream.collect(Collectors.toList());
    }

    /**
     * 根据指定元素对集合进行升序排序
     *
     * @param list  集合
     * @param keyExtractor  用来排序的元素
     * @param    函数输入类型的泛型
     * @param    函数结果类型的泛型
     * @return  排序后的集合
     */
    public static > List sorted(
            List list, Function<? super T, ? extends U> keyExtractor) {
        return streamOf(list).sorted(Comparator.comparing(keyExtractor)).collect(Collectors.toList());
    }

    /**
     * 根据指定元素对集合进行升序排序
     *
     * @param list  集合
     * @param keyExtractor  用来排序的元素
     * @param limit     排序后集合中保留的数量
     * @param    函数输入类型的泛型
     * @param    函数结果类型的泛型
     * @return  排序后的集合
     */
    public static > List sorted(
            List list, Function<? super T, ? extends U> keyExtractor, Integer limit) {
        return streamOf(list).sorted(Comparator.comparing(keyExtractor)).limit(limit).collect(Collectors.toList());
    }

    /**
     * 根据指定元素对集合进行降序排序
     *
     * @param list  集合
     * @param keyExtractor  用来排序的元素
     * @param    函数输入类型的泛型
     * @param    函数结果类型的泛型
     * @return  排序后的集合
     */
    public static > List sortedDesc(
            List list, Function<? super T, ? extends U> keyExtractor) {
        return streamOf(list).sorted(Comparator.comparing(keyExtractor).reversed()).collect(Collectors.toList());
    }

    /**
     *根据规则判断元素是否匹配
     *
     * @param list  集合
     * @param predicate 匹配规则
     * @param    元素类型
     * @return  匹配结果
     */
    public static  boolean anyMatch(List list, Predicate<? super T> predicate) {
        return streamOf(list).anyMatch(predicate);
    }

    /**
     * 将List集合转换成Map集合,同一个key时对value进行去重，保留第一个出现的value值
     *
     * @param list  集合
     * @param keyMapper     新的Map中的key
     * @param    参数的类型
     * @return  转换后的Map集合   
     */
    public static  Map< K, T> toMapDistinctFirst(List list, Function<? super T, ? extends K> keyMapper) {
        return streamOf(list).collect(Collectors.toMap(keyMapper, Function.identity(), (key1, key2) -> key1));
    }

    /**
     * 将List集合转换成Map集合,同一个key时对value进行去重，保留最后出现的value值
     *
     * @param list  集合
     * @param keyMapper     新的Map中的key
     * @param