Java 8 Stream特性

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java 8 Stream特性，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14656字，纯文字阅读大概需要21分钟。

内容图文

Java 8 新特性 java 8 Stream

　　一、Stream (流)到底是什么呢？

　答：是数据渠道，将数据源(集合，数组等)中的元素操作之后拍成新的序列

　　由定义可知，我们很轻松的就可以画个图

技术分享图片

一、获得流

            　　 @Test
    
            public
            void
             getStream() {
        
            //
            1.通过Collection获得提供的stream,parallelStream获得流
        List<String> stringList = new ArrayList<>();
        stringList.add("abc");
        stringList.add("bac");
        stringList.add("cab");
        Stream<String> stream = stringList.stream();
        //Stream<String> stringStream = stringList.parallelStream();

        //2.通过Arrays的静态方法  Arrays.stream 获得流
        Stream<String> stream1 = Arrays.stream(new String[]{"a", "b"});

        //3.通过Stream的静态方法of获得流
        Stream<String> stringStream = Stream.of(new String[]{"a", "b"});
        Stream<String> a = Stream.of("a", "b");

        //4.生成無限流
        Stream<Integer> iterate = Stream.iterate(1, (x) -> x * 2);
        Stream<Double> generate = Stream.generate(() -> Math.random());
    }

二、中间操作

2.1 筛选与切片

Emploee Dto

            import
             java.util.Objects;


            public
            class Employee implements Comparable<Employee> {
    private String name;
    private Integer age;
    private Status status;
    private Double salary;

    public String getName() {
        return name;
    }

    publicvoid setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    publicvoid setAge(Integer age) {
        this.age = age;
    }

    public Status getStatus() {
        return status;
    }

    publicvoid setStatus(Status status) {
        this.status = status;
    }

    public Double getSalary() {
        return salary;
    }

    publicvoid setSalary(Double salary) {
        this.salary = salary;
    }


    public Employee(String name, Integer age, Status status, Double salary) {
        this.name = name;
        this.age = age;
        this.status = status;
        this.salary = salary;
    }

    public Employee() {
    }


    @Override
    public String toString() {
        return "Employee{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ", status=" + status +
                ", salary=" + salary +
                ‘}‘;
    }

    @Override
    publicboolean equals(Object o) {
        if (this == o) returntrue;
        if (o == null || getClass() != o.getClass()) returnfalse;
        Employee employee = (Employee) o;
        return Objects.equals(name, employee.name) &&
                Objects.equals(age, employee.age) &&
                status == employee.status &&
                Objects.equals(salary, employee.salary);
    }

    @Override
    publicint hashCode() {
        return Objects.hash(name, age, status, salary);
    }

    @Override
    publicint compareTo(Employee o) {
        if (this.getAge() > o.getAge()) {
            return 1;
        }
        return -1;
    }

    publicenum Status {
        FREE,
        BUSY,
        VACATION;
    }
}

执行结果这里就不一一展示了

            /**
            
     * 筛选
     
            */
            
    @Test
    
            public
            void
             test1() {
        
            //
            
                1.生成流
        Stream<Employee> employeeStream = Stream.of(new Employee("张三", 17, Employee.Status.FREE, 999.99),
                new Employee("李四", 20, Employee.Status.BUSY, 9999.99),
                new Employee("王五", 23, Employee.Status.BUSY, 7777.00),
                new Employee("赵六", 25, Employee.Status.VACATION, 6666.66),
                new Employee("田七", 29, Employee.Status.FREE, 997.99),
                new Employee("李青", 37, Employee.Status.VACATION, 100000.99)
        );

        //操作流(这里为了方便就进行了终止操作，方便查看)
        //2 筛选出年龄大于20的员工信息        employeeStream.
                filter(e -> e.getAge() > 20).//Predicate<? super T> predicate 方法中需要一个断言型接口
                forEach(x -> System.out.println(x));//Consumer<? super T> action    }

    /**
     * 切片
     */
    @Test
    publicvoid test2() {
        //1.生成流
        Stream<Employee> employeeStream = Stream.of(new Employee("张三", 17, Employee.Status.FREE, 999.99),
                new Employee("李四", 20, Employee.Status.BUSY, 9999.99),
                new Employee("王五", 23, Employee.Status.BUSY, 7777.00),
                new Employee("赵六", 25, Employee.Status.VACATION, 6666.66),
                new Employee("田七", 29, Employee.Status.FREE, 997.99),
                new Employee("李青", 37, Employee.Status.VACATION, 100000.99),
                new Employee("李青", 37, Employee.Status.VACATION, 100000.99),
                new Employee("李青", 37, Employee.Status.VACATION, 100000.99)
        );

        //操作流(这里为了方便就进行了终止操作，方便查看)
        
        //2.1 筛选出年龄大于20的前2个员工信息/*employeeStream.
                filter(e -> e.getAge() > 20).
                limit(2).//Predicate<? super T> predicate 方法中需要一个断言型接口
                forEach(x -> System.out.println(x));//Consumer<? super T> action*///2.2 筛选出年龄大于20的员工信息(排除前两个)/* employeeStream.
                filter(e->e.getAge()>20).
                skip(2).
                forEach(x -> System.out.println(x));*///2.3 对流进行去重(对象的重复是根据hashCode和equals方法来判断的，所有需要重写这两个方法)        employeeStream.
                distinct().
                forEach(x -> System.out.println(x));
    }

2.2映射

映射主要有2个函数map和flatMap 主要用来提取对象中的属性

map(Function<? super T, ? extends R> mapper)

                /**
                
     * 映射
     
                */
                
    @Test
    
                public
                void
                 test3() {
        
                //
                1.生成流
        Stream<Employee> employeeStream = Stream.of(new Employee("张三", 17, Employee.Status.FREE, 999.99),
                new Employee("李四", 20, Employee.Status.BUSY, 9999.99),
                new Employee("王五", 23, Employee.Status.BUSY, 7777.00),
                new Employee("赵六", 25, Employee.Status.VACATION, 6666.66),
                new Employee("田七", 29, Employee.Status.FREE, 997.99),
                new Employee("李青", 37, Employee.Status.VACATION, 100000.99)
        );

        //操作流(这里为了方便就进行了终止操作，方便查看)
        //2 取出所有员工的姓名        employeeStream.
                map(e -> e.getName()).
                forEach(System.out::println);
    }

View Code

flatMap (Function<? super T, ? extends R> mapper) 平铺映射

为什么已经有一个映射方法，还需要一个flatMap呢？话不多说，上代码

            /**
            
     * 普通映射
     
            */
            
    @Test
    
            public
            void
             test4() {
        
            //
            1.生成流
        Stream<String> abdas = Stream.of("abdas", "das", "das");
        //操作流(这里为了方便就进行了终止操作，方便查看)
        Stream<Stream<String>> streamStream = abdas.map(e -> transfer(e));//流中嵌流，数据很不直观
        streamStream.forEach(e -> e.forEach(System.out::println));//虽然还是可以拿到所有字符的集合，但是如果是对象呢？
    }

    private Stream<String> transfer(String s) {
        List<String> list = new ArrayList<>();
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            String s1 = chars[i] + "";
            list.add(s1);
        }
        return list.stream();
    }

平铺映射

            /**
            
     * 平铺映射
     
            */
            
    @Test
    
            public
            void
             test5() {
        
            //
            1.生成流
        Stream<String> abdas = Stream.of("abdas", "das", "das");
        //操作流(这里为了方便就进行了终止操作，方便查看)
        Stream<String> stringStream = abdas.flatMap(e -> transfer(e));
        stringStream.forEach(System.out::println);
    }

2者效果一样

2.3排序

sort

            /**
            
     * 排序
     
            */
            
    @Test
    
            public
            void
             test6() {
        
            //
            1.生成流
        Stream<Employee> employeeStream = Stream.of(new Employee("张三", 16, Employee.Status.FREE, 999.99),
                new Employee("李四", 16, Employee.Status.BUSY, 9999.99),
                new Employee("王五", 23, Employee.Status.BUSY, 7777.00),
                new Employee("赵六", 37, Employee.Status.VACATION, 6666.66),
                new Employee("田七", 29, Employee.Status.FREE, 997.99),
                new Employee("李青", 25, Employee.Status.VACATION, 100000.99)
        );
        //操作流(这里为了方便就进行了终止操作，方便查看)
        //2.1 自然排序  此处必须要实现接口Comparable

            //
            employeeStream.sorted().forEach(System.out::println);

//2.2 自定义排序
employeeStream.sorted((e1, e2) -> {
    if (e1.getAge() == e1.getAge()) {
        return e1.getName().compareTo(e2.getName());
    } else {
        return Integer.compare(e1.getAge(), e2.getAge());
    }
}).forEach(System.out::println);

三、终止操作

3.1 查找与匹配

Match

                /**
                
     * Match
     
                */
                
    @Test
    
                public
                void
                 test7() {
        
                //
                1.生成流
        Stream<String> stringStream = Stream.of("abdas", "das", "das");
        //操作流(这里为了方便就进行了终止操作，方便查看)

        //2.1 集合中所有元素是不是都满足条件
        //boolean allMatch = stringStream.allMatch(e -> e.startsWith("d"));//Predicate<? super T> predicate
        //System.out.println(allMatch); //false

        //2.2 集合中元素只要有一个满足条件则返回true，否则返回false
        //boolean anyMatch = stringStream.anyMatch(e -> e.startsWith("d"));
        //System.out.println(anyMatch);//true

        //2.3 集合中所有元素不满足条件则返回true，否则返回falseboolean noneMatch = stringStream.noneMatch(e -> e.startsWith("c"));
        System.out.println(noneMatch);
    }

View Code

Find and Statistics

                /**
                
     * Find
     * statistics
     
                */
                
    @Test
    
                public
                void
                 test8() {
        
                //
                1.生成流
        Stream<String> stringStream = Stream.of("abc", "defg", "hijqn");

        List<String> stringList = new ArrayList<>();
        stringList.add("abc");
        stringList.add("defg");
        stringList.add("hijqn");
        stringList.add("784");
        stringList.add("852");
        stringList.add("943");
        stringList.add("120");
        stringList.add("120");

        List<Long> longList = new ArrayList<>();

        longList.add(784l);
        longList.add(852l);
        longList.add(943l);
        longList.add(120l);
        longList.add(120l);
        //操作流(这里为了方便就进行了终止操作，方便查看)

        //2.1 findFirst 查找集合中第一个元素  Optional 是java8的一个容器类，能很好的避免空指针异常/*Optional<String> streamFirst = stringStream.findFirst();
        Optional<String> listFirst = stringList.parallelStream().findFirst();
        System.out.println("streamFirst:" + streamFirst.get());
        System.out.println("listFirst:" + listFirst.get());*///2.2 findAny/*Optional<String> streamFirst = stringStream.findAny();
        Optional<String> listFirst = stringList.parallelStream().findAny();
        System.out.println("streamFirst:" + streamFirst.get());//第一个元素
        System.out.println("listFirst:" + listFirst.get());//随机一个元素*///count 统计流中有多少个元素/*long count = stringStream.count();
        System.out.println(count);*///max(Comparator<? super T> comparator)
        Optional<Long> max = longList.stream().max(Long::compareTo);
        System.out.println(max.orElse(99999999l));
        
        //min(Comparator<? super T> comparator) 
        Optional<String> min = stringList.stream().min(String::compareTo);
        System.out.println(min.orElse("0"));
    }

View Code

3.2 规约 reduce

                /**
                
     * reduce
     
                */
                
    @Test
    
                public
                void
                 test9() {
        
                //
                1.生成流
        Stream<Employee> employeeStream = Stream.of(new Employee("张三", 16, Employee.Status.FREE, 999.99),
                new Employee("李四", 16, Employee.Status.BUSY, 9999.99),
                new Employee("王五", 23, Employee.Status.BUSY, 7777.00),
                new Employee("赵六", 37, Employee.Status.VACATION, 6666.66),
                new Employee("田七", 29, Employee.Status.FREE, 997.99),
                new Employee("李青", 25, Employee.Status.VACATION, 100000.99),
                new Employee("李青", 26, Employee.Status.VACATION, 100000.99),
                new Employee("李青", 35, Employee.Status.VACATION, 100000.99)
        );

        //操作流(这里为了方便就进行了终止操作，方便查看)
        Optional<Double> reduce = employeeStream.
                filter((s) -> s.getName().equals("李青")).
                map(e -> e.getSalary()).
                reduce(Double::sum);

        System.out.println(reduce.orElse(0.00));
    }

View Code

3.2 收集collect

                /**
                
     * collect
     
                */
                
    @Test
    
                public
                void
                 test10() {
        
                //
                1.生成流
        Stream<Employee> employeeStream = Stream.of(new Employee("张三", 16, Employee.Status.FREE, 999.99),
                new Employee("李四", 16, Employee.Status.BUSY, 9999.99),
                new Employee("王五", 23, Employee.Status.BUSY, 7777.00),
                new Employee("赵六", 37, Employee.Status.VACATION, 6666.66),
                new Employee("田七", 29, Employee.Status.FREE, 997.99),
                new Employee("李青", 25, Employee.Status.VACATION, 100000.99),
                new Employee("李青", 26, Employee.Status.VACATION, 100000.99),
                new Employee("李青", 35, Employee.Status.VACATION, 100000.99)
        );
        //年龄小于25岁的员工信息/*List<Employee> employeeList = employeeStream.
                filter(e -> e.getAge() <= 25).
                collect(Collectors.toList());
        employeeList.forEach(System.out::println);*///所有员工姓名/*Set<String> set = employeeStream.
                map(Employee::getName).
                collect(Collectors.toSet());
        set.forEach(System.out::println);*///所有员工信息（去重）/*HashSet<Employee> collect = employeeStream.
                collect(Collectors.toCollection(HashSet::new));
        System.out.println(collect);*///员工个数/*Long collect = employeeStream.collect(Collectors.counting());
        System.out.println(collect);*///平均工资/*Double avg = employeeStream.collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);*///工资最高的员工信息/*Optional<Employee> optionalEmployee = employeeStream.collect(Collectors.maxBy((e1, e2) -> e1.getSalary().compareTo(e2.getSalary())));
        System.out.println(optionalEmployee.orElse(null));*///工资最低的员工信息/*Optional<Employee> optionalEmployee = employeeStream.collect(Collectors.minBy((e1, e2) -> e1.getSalary().compareTo(e2.getSalary())));
        System.out.println(optionalEmployee.orElse(null));*///工资总和/* Double allCounts = employeeStream.collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println("工资总和" + allCounts);*///工资信息摘要
        DoubleSummaryStatistics dss = employeeStream.collect(Collectors.summarizingDouble(Employee::getSalary));
        double avg = dss.getAverage();
        double sum = dss.getSum();
        long count = dss.getCount();
        double max = dss.getMax();
        double min = dss.getMin();
        System.out.println(avg);
        System.out.println(sum);
        System.out.println(count);
        System.out.println(max);
        System.out.println(min);
    }

View Code

3.3 分区，分组，连接字符串

                 @Test
    
                public
                void
                 test11() {
        Stream<Employee> employeeStream = Stream.of(new Employee("张三", 16, Employee.Status.FREE, 999.99),
                new Employee("李四", 16, Employee.Status.BUSY, 9999.99),
                new Employee("王五", 23, Employee.Status.BUSY, 7777.00),
                new Employee("赵六", 37, Employee.Status.VACATION, 6666.66),
                new Employee("田七", 29, Employee.Status.FREE, 997.99),
                new Employee("李青", 25, Employee.Status.VACATION, 100000.99),
                new Employee("李青", 26, Employee.Status.VACATION, 100000.99),
                new Employee("李青", 35, Employee.Status.VACATION, 100000.99)
        );

        //按照工资是否大于9000来分区  [true:{.....} false:{......}]/*Map<Boolean, List<Employee>> booleanListMap = employeeStream.collect(Collectors.partitioningBy(e -> e.getSalary() > 9000.0));
        System.out.println(booleanListMap);*///按照状态分组/*Map<Employee.Status, List<Employee>> statusListMap = employeeStream.collect(Collectors.groupingBy(Employee::getStatus));*///多级分组/*Map<Employee.Status, Map<String, Map<String, List<Employee>>>> map = employeeStream.collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy(e -> {
                    if (e.getAge() <= 25) {
                        return "青年";
                    } else {
                        return "中年";
                    }
                }, Collectors.groupingBy(e -> {
                    if (e.getSalary() > 9000) {
                        return "高于平均工资";
                    } else {
                        return "低于平均工资";
                    }
                })
        )));
        System.out.println(map);*///拼接名称/*String str = employeeStream.map(Employee::getName).collect(Collectors.joining());
        System.out.println(str);*///拼接名称，带前缀和间隔
        String joinStr = employeeStream.map(Employee::getName).collect(Collectors.joining(",", " start ", " end "));
        System.out.println(joinStr);
    }

View Code

四、注意事项

　　　　1.Stream不会出仓元素

　　　　2.Stream不会改变数据源中的数据

　　　　3.Stream是惰性执行的

写两段代码证明Stream是惰性执行的。

             @Test
    
            public
            void
             test() {
        List<String> stringList = new ArrayList<>();
        stringList.add("abc");
        stringList.add("bac");
        stringList.add("cab");
        Stream<String> stringStream = stringList.stream().peek(System.out::println);
        System.out.println("执行完成");
    }

            结果：字符串并没有被打印出来
D:\java\jdk\bin\java.exe 

执行完成

Process finished with exit code 0

II.

            public
            class
             TestStream {
    @Test
    
            public
            void
             test() {
        List<String> stringList = new ArrayList<>();
        stringList.add("abc");
        stringList.add("bac");
        stringList.add("cab");
        Stream<String> stringStream = stringList.stream().peek(System.out::println);
        stringStream.collect(Collectors.toList());//使用流
        System.out.println("执行完成");
    }
}

            结果：字符串正常输出
D:\java\jdk\bin\java.exe

abc
bac
cab
执行完成

Process finished with exit code 0

4.流不能被重复使用

III

            @Test
    
            public
            void
             test() {
        List<String> stringList = new ArrayList<>();
        stringList.add("abc");
        stringList.add("bac");
        stringList.add("cab");
        Stream<String> stringStream = stringList.stream().peek(System.out::println);
        stringStream.collect(Collectors.toList());
        stringStream.collect(Collectors.toList());
        System.out.println("执行完成");
    }
java.lang.IllegalStateException: stream has already been operated upon or closed

原文：https://www.cnblogs.com/wblogw/p/12283387.html

内容总结

以上是互联网集市为您收集整理的Java 8 Stream特性全部内容，希望文章能够帮你解决Java 8 Stream特性所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1115940.html

来源：【匿名】

【上一篇】java基础第九天课程总结【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java 8 Stream特性】教程文章相关的互联网学习教程文章

一.作用域表示变量或函数起作用的区域,指代了它们在什么上下文中执行,Javascript总作用域一共有两种:全局作用域和本地作用域,在Javascript中本地作用域是按照函数来区分的。var global = "11"; //全局作用域function fun() {var local = "22";//本地作用域1 } function fun2() {var local2 = "22";//本地作用域2for (var i=0;i<100;i++) {//本地作用域2} } JavaScript的作用域和C#的或者Java的作用域不是太一样,C#和Java中一个"...

java9新特性-1-概述【代码】

经过4次跳票，历经曲折的java 9 终于终于在2017年9月21日发布。 2.哪些人适合看这套视频？已经熟悉或熟练运用java 8 及之前 java 版本的开发人员、科研人员、学生及兴趣爱好者本套视频不会从头介绍java的基本语法、面向对象等核心内容，这里讲解基于java 8 之后java 9 中的新特性有兴趣学习java语言的朋友，可以下载学习《尚硅谷java基础经典20天视频》 3. Java 9 中哪些不得不说的新特性？java 9 提供了超过150项新功能特性，包...

[转]理解java的三大特性之多态【代码】【图】

面向对象编程有三大特性：封装、继承、多态。封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。，同时继承也为实现多态做了铺垫。那么什么是多态呢？多态的实现机制又是什么？请看我一一为你揭开：所谓多态就是指程序中定义的引用变量...

ES6新特性：Javascript中Generator(生成器)【代码】【图】

ES6的很多特性都跟Generator扯上关系，而且实际用处比较广，包含了任何需要异步的模块，比如ajax， filesystem，或者数组对象遍历等都可以用到；　　Generator的使用：　　Generator函数和普通的函数区别有两个， 1：function和函数名之间有一个*号， 2：函数体内部使用了yield表达式；比如这样：function* gen() {yield"1";yield"2" } 　　这个玩意儿如果运行的话，会返回一个Iterator实例，然后再执行Iterator实例的next()方...

JDK1.5的新特性：javabean、注解类、类加载器【图】

关于Java基础的文章，我觉得写得还可以，以前发在了我其它的博客了，肯定是原创，现在再分享给大家出来。--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 一、javaBean一、概述JavaBean是符合某种规范的Java组件，也就是Java类。它必须满足如...

java基础1.5版后新特性自动装箱拆箱 Date SimpleDateFormat Calendar.getInstance()获得一个日历对象抽象不要生成对象 get set add System.arrayCopy()用于集合等的扩容

8种基本数据类型的8种包装类byte Byteshort Shortint Integerlong Longfloat Floatdouble Doublechar Characterboolean BooleanInteger a=127; Integer b=127;//虚拟机自动装箱时进行了特殊处理，-127~128以下的自动取有过的System.out.println(a==b);结果为true如果是Integer a=128; Integer b=128;System.out.println(a==b);结果为falseSystem.out.println(a.equals(b)); 比较的都为内容，因复写过equals结果为true原文：https:/...

深入理解JavaScript的闭包特性如何给循环中的对象添加事件

初学者经常碰到的,即获取HTML元素集合，循环给元素添加事件。在事件响应函数中(event handler)获取对应的索引。但每次获取的都是最后一次循环的索引。原因是初学者并未理解JavaScript的闭包特性。有个网友问了个问题，如下的html，为什么点击所有的段落p输出都是5，而不是alert出对应的0，1，2，3，4。1. <!DOCTYPE HTML>2. <html>3. <head>4. <meta charset="utf-8" />5. <title>闭包演示</title>6. <style type="text/css"...

java8新特性学习三(Stream API)【代码】【图】

java8中有两大最为重要的改变。一个是Lambda表达式，另一个是Stream API。Stream 中文称为 “流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。Stream API提供了一种高效且易于使用的处理数据的方式。先说下Stream的优势：Collection是一种静态的内存数据结构，面向内存存储在内存中，而Stream是有关计算的，面向CPU通过CPU实现计算的。它是java对...

Knowledge Point 20180302 深究Java的跨平台特性【图】

本章主题:从骨子里看Java的跨平台;本文内容部分摘自https://www.cnblogs.com/roger-yu/p/5827452.html　　有过基础Java知识的开发人员都知道Java是跨平台的，可我们知道Java为什么要跨平台吗，Java的跨平台又是如何实现的呢？下面我们来一一了解。1.什么是平台Java是可以跨平台的编程语言，那我们首先得知道什么是平台，Java是一个高级开发语言,通过操作系统提供的接口进行开发,所以这里的平台主要指的就是操作系统了。　　操作系统...

Java1.8新特性 - Java内置的四大核心函数式接口【代码】

Java内置的四大核心函数式接口Consumer：消费型接口对类型为T的对象应用操作，包含方法：void accept(T t)public class TestLambda02 {public static void main(String[] args) {testConsumer(9999, (x) -> {System.out.println("打游戏花费：" + x);});}public static void testConsumer(double money, Consumer<Double> consumer) {consumer.accept(money);} }Supplier：供给型接口返回包含类型为T的对象，包含方法：T get()publ...

Java三大特性之---封装【代码】

封装从字面上来理解就是包装的意思，专业点就是信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节（当然也无从知道），但可以通过该对象对外的提...

java9新特性-7-语法改进：接口的私有方法【代码】

1.官方Feature213: Milling Project CoinSupport for private methods in interfaces was briefly in consideration for inclusion in Java SE 8 as part of the effort to add support for Lambda Expressions, but was withdrawn to enable better focus on higher priority tasks for Java SE 8. It is now proposed that support for private interface methods be undertaken thereby enabling non abstract methods of an in...

JAVA 8 新特性 Lambda表达式【代码】【图】

摘自b站尚硅谷JAVA视频教程 Runnable r1 = new Runnable() {@Overridepublicvoid run() {System.out.println("北京");} }; r1.run();Runnable r2 = ()->System.out.println("上海"); r2.run();Comparator<Integer> c = (o1,o2)->Integer.compare(o1,o2); int res = c.compare(12,21); //方法引用 Comparator<Integer> c1 = Integer::compare; int com = c1.compare(32,21); System.out.println(com); 原文：https://www.c...

JavaScript的检测属性、属性特性、枚举属性【代码】

/* 检测属性检测属性可以通过三种方式 1.通过in运算符 2.通过hasOwnPerperty() 如果给定的属性是继承属性将返回false 3.通过propertyIsEnumerable()：只有检测到的自有属性且这个属性的可枚举性为true时它才返回true,某些内置对象是不可枚举的，通常由JavaScript代码创建的对象的属性是可枚举的。 */var o = { x: 1};"x" in o.x; //true "y" in o.x; //false "toString" in o.x //true o继承toString 属性o.hasOwnProperty("x");...

ABAP和Java里关于DEFAULT(默认)机制的一些语言特性【代码】【图】

ABAP 740的新语法：上图的代码相当于:DATA: ls_data LIKE LINE OF it_data. READ TABLE it_data INTO ls_data WITH KEY object_ext = cl_crm_prodil_bo_names=>gc_prod_root. CALL METHOD add_dataEXPORTINGir_child_object = ir_root_objectis_data = ls_data.由此可见新语法比较简洁，能少写3行代码。但是这样有一个缺陷，在新语法下如果it_data内表内不存在object_ext的值为cl_crm_prodil_bo_names=>gc_prod_root的记录，就会终...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / Java 8 Stream特性

Java 8 Stream特性

内容导读

内容图文

Java 8 新特性 java 8 Stream

一、Stream (流)到底是什么呢？

一、获得流

二、中间操作

2.1 筛选与切片

2.2映射

2.3排序

三、终止操作

3.1 查找与匹配

3.2 规约 reduce

3.2 收集collect

3.3 分区，分组，连接字符串

四、注意事项

1.Stream不会出仓元素

2.Stream不会改变数据源中的数据

3.Stream是惰性执行的

4.流不能被重复使用

内容总结

内容备注

内容手机端

【Java 8 Stream特性】教程文章相关的互联网学习教程文章

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程

　　一、Stream (流)到底是什么呢？

　　　　1.Stream不会出仓元素

　　　　2.Stream不会改变数据源中的数据

　　　　3.Stream是惰性执行的