java8 新特性 Stream流 分组 排序 过滤 多条件去重

    private static List<User> list = new ArrayList<User>();

    public static void main(String[] args) {
        list =  Arrays.asList(
                new User(1, "a", 10),
                new User(4, "d", 19),
                new User(5, "e", 13),
                new User(2, "b", 14),
                new User(3, "a", 10),
                new User(6, "f", 16)
                );

        long start = System.currentTimeMillis();

        order();

        println(String.format("耗时[%s]毫秒", (System.currentTimeMillis() - start)));

    }

    /**
     * 多条件去重
     * @param list
     */
    public static void order() {
        list.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(
                        Comparator.comparing(o -> o.getAge() + ";" + o.getName()))), ArrayList::new)).forEach(u -> println(u));
    }

    public static void group() {
        Map<Integer, List<User>> collect = list.stream().collect(Collectors.groupingBy(User::getAge));
        System.out.println(collect);
    }

    /**
     * filter过滤
     * @param list
     */
    public static void filterAge() {
        list.stream().filter(u -> u.getAge() == 10).forEach(u -> println(u));
    }

    /**
     * sorted排序
     */
    public static void stord() {
        list.stream().sorted(Comparator.comparing(u-> u.getAge())).forEach(u -> println(u));

    }
    /**
     * limit方法限制最多返回多少元素
     */
    public static void limit() {
        list.stream().limit(2).forEach(u -> println(u));
    }
    /**
     * 不要前多n个元素,n大于满足条件的元素个数就返回空的流
     */
    public static void skip() {
        list.stream().skip(2).forEach(u -> println(u));
    }
    // 最大值 最小值
    public static void statistics() {
        Optional<User> min = list.stream().min(Comparator.comparing(User::getUserId));
        println(min);
        Optional<User> max = list.stream().max(Comparator.comparing(User::getUserId));
        println(max);
    }

    // 统计
    public static void summarizingInt(){
        IntSummaryStatistics statistics = list.stream().collect(Collectors.summarizingInt(User::getAge));
        double average = statistics.getAverage();
        long count = statistics.getCount();
        int max = statistics.getMax();
        int min = statistics.getMin();
        long sum = statistics.getSum();
        println(average);
        println(count);
        println(min);
        println(sum);
        println(max);

    }
    /**
     * 转set
     */
    public static void toSet() {
        Set<User> collect = list.stream().collect(Collectors.toSet());
        Iterator<User> iterator = collect.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next().getUserId());
        }
    }

    /**
     * 转map
     */
    public static void toMap() {
        Map<Integer, User> collect = list.stream().collect(Collectors.toMap(User::getUserId, u -> u));
        for (Integer in : collect.keySet()) {
          User u = collect.get(in);//得到每个key多对用value的值
          println(u);
        }
    }
    /**
     *map
     */
    public static void map() {
        list.stream().map(User::getUserId).forEach(userId -> println(userId));
        list.stream().mapToInt(User::getAge).forEach(userId -> println(userId));
        list.stream().mapToDouble(User::getUserId).forEach(userId -> println(userId));
        list.stream().mapToLong(User::getUserId).forEach(userId -> println(userId));
    }

    /**
     * 查找与匹配
     * allMatch方法与anyMatch差不多,表示所有的元素都满足才返回true。noneMatch方法表示没有元素满足
     */
    public static void anyMatch() {
        boolean anyMatch = list.stream().anyMatch(u -> u.getAge() == 100);
        boolean allMatch = list.stream().allMatch(u -> u.getUserId() == 10);
        boolean noneMatch = list.stream().noneMatch(u -> u.getUserId() == 10);
        println(anyMatch);
        println(allMatch);
        println(noneMatch);
    }

    /**
     * reduce操作
     */
    public static void reduce() {
        Optional<Integer> sum = list.stream().map(User::getAge).reduce(Integer::sum);
        Optional<Integer> max = list.stream().map(User::getAge).reduce(Integer::max);
        Optional<Integer> min = list.stream().map(User::getAge).reduce(Integer::min);
        println(sum);
        println(max);
        println(min);
    }
    /**
     * 公共输出
     * @param c
     */
    public static void println(Object c) {
        System.out.println(c.toString());
    }
    

private static List<User> list = new ArrayList<User>();public static void main(String[] args) {list =  Arrays.asList(new User(1, "a", 10),new User(4, "d", 19),new User(5, "e", 13),new User(2, "b", 14),new User(3, "a", 10),new User(6, "f", 16));long start = System.currentTimeMillis();order();println(String.format("耗时[%s]毫秒", (System.currentTimeMillis() - start)));}/** * 多条件去重 * @param list */public static void order() {list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getAge() + ";" + o.getName()))), ArrayList::new)).forEach(u -> println(u));}public static void group() {Map<Integer, List<User>> collect = list.stream().collect(Collectors.groupingBy(User::getAge));System.out.println(collect);}/** * filter过滤 * @param list */public static void filterAge() {list.stream().filter(u -> u.getAge() == 10).forEach(u -> println(u));}/** * sorted排序 */public static void stord() {list.stream().sorted(Comparator.comparing(u-> u.getAge())).forEach(u -> println(u));}/** * limit方法限制最多返回多少元素 */public static void limit() {list.stream().limit(2).forEach(u -> println(u));}/** * 不要前多n个元素,n大于满足条件的元素个数就返回空的流 */public static void skip() {list.stream().skip(2).forEach(u -> println(u));}// 最大值 最小值public static void statistics() {Optional<User> min = list.stream().min(Comparator.comparing(User::getUserId));println(min);Optional<User> max = list.stream().max(Comparator.comparing(User::getUserId));println(max);}// 统计public static void summarizingInt(){IntSummaryStatistics statistics = list.stream().collect(Collectors.summarizingInt(User::getAge));double average = statistics.getAverage();long count = statistics.getCount();int max = statistics.getMax();int min = statistics.getMin();long sum = statistics.getSum();println(average);println(count);println(min);println(sum);println(max);}/** * 转set */public static void toSet() {Set<User> collect = list.stream().collect(Collectors.toSet());Iterator<User> iterator = collect.iterator();while(iterator.hasNext()) {System.out.println(iterator.next().getUserId());}}
/** * 转map */public static void toMap() {Map<Integer, User> collect = list.stream().collect(Collectors.toMap(User::getUserId, u -> u));for (Integer in : collect.keySet()) {  User u = collect.get(in);//得到每个key多对用value的值  println(u);}}/** *map */public static void map() {list.stream().map(User::getUserId).forEach(userId -> println(userId));list.stream().mapToInt(User::getAge).forEach(userId -> println(userId));list.stream().mapToDouble(User::getUserId).forEach(userId -> println(userId));list.stream().mapToLong(User::getUserId).forEach(userId -> println(userId));}/** * 查找与匹配 * allMatch方法与anyMatch差不多,表示所有的元素都满足才返回true。noneMatch方法表示没有元素满足 */public static void anyMatch() {boolean anyMatch = list.stream().anyMatch(u -> u.getAge() == 100);boolean allMatch = list.stream().allMatch(u -> u.getUserId() == 10);boolean noneMatch = list.stream().noneMatch(u -> u.getUserId() == 10);println(anyMatch);println(allMatch);println(noneMatch);}/** * reduce操作 */public static void reduce() {Optional<Integer> sum = list.stream().map(User::getAge).reduce(Integer::sum);Optional<Integer> max = list.stream().map(User::getAge).reduce(Integer::max);Optional<Integer> min = list.stream().map(User::getAge).reduce(Integer::min);println(sum);println(max);println(min);}/** * 公共输出 * @param c */public static void println(Object c) {System.out.println(c.toString());}
--------------------- 作者:anningx 来源:CSDN 原文:https://blog.csdn.net/qq_39739458/article/details/84970293 版权声明:本文为博主原创文章,转载请附上博文链接!

原文地址:https://www.cnblogs.com/EveningWind/p/10530209.html

时间: 2024-10-09 19:56:26

java8 新特性 Stream流 分组 排序 过滤 多条件去重的相关文章

Java8新特性——stream流

一.基本API初探 package java8.stream; import java.util.Arrays; import java.util.IntSummaryStatistics; import java.util.List; import java.util.Random; import java.util.stream.Collectors; import java.util.stream.IntStream; /** * @author [email protected] * @

Java8 新特性 Stream 无状态中间操作

无状态中间操作 Java8 新特性 Stream 练习实例 中间无状态操作,可以在单个对单个的数据进行处理.比如:filter(过滤)一个元素的时候,也可以判断,比如map(映射)... 过滤 filter 映射 map 扁夹化 flatMap 遍厉 peek 过滤 filter 接收一个谓词断言,boolean Pridicate< T > 根据返回值类型来确定是否过滤这一条属性. // 过滤 filter @Test public void filterTest() { list.stre

Java8 新特性 Stream 短路终端操作

短路终端操作 Java8 新特性 Stream 练习实例 传入一个谓词,返回传为boolean,如果符合条件,则直接结束流. 匹配所有 allMatch 任意匹配 anymMatch 不匹配 noneMatch 查找首个 findFirst 查找任意 findAny 匹配所有 allMatch //匹配所有 allMatch @Test public void allMatchTest() { boolean b = list.stream() //所有的商品价格都大于40 .allMatch(

Java8 新特性 Stream 非短路终端操作

非短路终端操作 Java8 新特性 Stream 练习实例 非短路终端操作,就是所有的元素都遍厉完,直到最后才结束.用来收集成自己想要的数据. 方法有: 遍厉 forEach 归约 reduce 最大值 max 最小值 min 聚合 collect 计数 count 遍厉 forEach //遍厉 forEach @Test public void forEachTest() { list.stream() .forEach(iter -> //以json格式输出 System.out.prin

Java8 新特性之流式数据处理

一. 流式处理简介 在我接触到java8流式处理的时候,我的第一感觉是流式处理让集合操作变得简洁了许多,通常我们需要多行代码才能完成的操作,借助于流式处理可以在一行中实现. 比如我们希望对一个包含整数的集合中筛选出所有的偶数,并将其封装成为一个新的List返回,那么在java8之前,我们需要通过如下代码实现: List<Integer> evens = new ArrayList<>(); for (final Integer num : nums) { if (num % 2 =

Java8 新特性 Stream() 创建流

通过Controllere类的Stream()和parallelStream()创建流 //通过集合创建流 @Test public void test1() { String arr[] = new String[]{"a", "b", "c"}; //把数组转换成集合 List<String> list = Arrays.asList(arr); //生成stream流(串行流) Stream<String> stre

Java8新特性Stream API与Lambda表达式详解(1)

1 为什么需要Stream与Lambda表达式? 1.1  为什么需要Stream Stream作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念.它也不同于 StAX 对 XML 解析的 Stream,也不是 Amazon Kinesis 对大数据实时处理的 Stream.Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于对集合对象进行各种非常便利.高效的聚合操作(aggr

java8 新特性 Stream

1. Stream初体验 我们先来看看Java里面是怎么定义Stream的: A sequence of elements supporting sequential and parallel aggregate operations. 我们来解读一下上面的那句话: Stream是元素的集合,这点让Stream看起来用些类似Iterator: 可以支持顺序和并行的对原Stream进行汇聚的操作: 大家可以把Stream当成一个高级版本的Iterator.原始版本的Iterator,用户只能一个一

java8新特性——Stream

一.stream介绍 stream(流)是一个来自数据源的元素队列 集合讲的是数据,而流讲的是计算 注意: ①stream自己不会存储元素 ②stream不会改变源对象,相反他会返回一个持有结果的新stream ③stream操作是延时执行的,这意味着他们会等到需要结果的时候才执行 stream操作的三个步骤 ①创建stream //1.通过Collection 系列集合提供的stream()[串行流]或 [并行流]来生成流 List list = new ArrayList(); Stream