zoukankan      html  css  js  c++  java
  • 30分钟速懂Java8新特性!

     

    原文:https://blog.csdn.net/u010425776/article/details/52334455 ,如有侵权请即使联系,谢谢

    1. 储备知识

    如果以下文章过于晦涩难懂的话,建议诸位可以看看此套教程:https://4m.cn/37UKQ 。

    好了,进入正题,在了解Lambda表达式之前首先需要了解以下预备知识。

    1.1 如何成为一名高级码农?

    如果老板让你写一个用于毁灭地球的函数,而你写了一个毁灭行星的函数,若要毁灭地球只需将毁灭地球的过程传递给“毁灭行星”。能做到这一点,你就是一名高级码农。

    以上这个问题体现了程序可扩展性的思想。总结一下,要成为一名高级码农,在编码的时候要以发展的眼光看待问题。一个具体问题到来的时候,你需要基于当前问题抽象出解决这一类问题的办法,那么当相似的问题到来时,你只需花少量的时间就能完成任务,而且避免了代码复制,降低了bug的风险。

    1.2 实现程序可扩展性的例子

    在Java8以前,要实现程序的可扩展性,我们常用匿名内部类传递用于扩展的代码,举个例子:

    实现一个能从List集合中筛选指定对象的函数filter。
    1. 若List中存放Person对象,要求筛选出30岁以上的Person
    2. 若List中存放Apple,要求筛选出红色的Apple

    使用匿名内部类的解决方案:

    • 实现filter函数
    List<T> filter(List<T> list, FilterProcessor filterProcessor){
        List<T> result = new ArrayList<T>();
        for(T t : list){
            if(filterProcessor.process(t))
                result.add(t);
        }
        return list;
    }
    
    • 定义FilterProcessor接口
    interface FilterProcessor<T>{
        boolean process(T);
    }
    
    • 使用匿名内部类实现筛选出30岁以上的Person
    List<Person> result = filter(list, new FilterProcessor<Person>(){
        boolean process(Person person){
            if(person.getAge()>=30)
                return true;
            return false;
        }
    });
    
    • 使用匿名内部类筛选出红色的Apple
    List<Apple> result = filter(list, new FilterProcessor<Apple>(){
        boolean process(Apple apple){
            if(apple.getColor().equals("red"))
                return true;
            return false;
        }
    });
    

    若要增加新的筛选规则,只需给filter函数传递新的匿名内部类即可。程序具有了可扩展性,恭喜你已经成为一名高级码农!

    1.3 啥是“策略模式”?

    上述过程总结来说,当我们需要解决同一类问题的时候,若发现这类问题大部分处理过程是一致的,只是核心步骤存在差异,这时候就可以使用上述方式:先把函数相同的部分写好,再抽象出一个接口,不同部分的代码放在接口的实现类中。要使用时,只需将实现类的对象传递给该函数即可。
    这种方式在设计模式中称为“策略模式”。

    1.4 使用匿名内部类实现策略模式的弊端?

    使用匿名内部类实现策略模式代码比较冗余,不易阅读,就像这样:

    List<Apple> result = filter(list, new FilterProcessor<Apple>(){
        boolean process(Apple apple){
            if(apple.getColor().equals("red"))
                return true;
            return false;
        }
    });
    

    Java8提出了Lambda表达式,它是实现策略模式的另外一种方式,目的就是为了使代码简单清晰。
    使用Lambda表达式实现相同功能:

    List<Apple> result = filter(list, (Apple apple)—>apple.getColor().equals("red"));
    

    这样是不是简单多了!Lambda表达式本质上是将一个函数的代码作为一个参数或变量进行传递,这种处理方式有个专门的名字——函数式编程。

    1.5 啥是函数式编程?

    所谓“函数式”编程,就是将函数的代码当作一个变量,传递给另一个变量或传递给一个函数,这种编程方式就称为“函数式编程”。
    Java8中采用Lambda表达式实现函数式编程,它是策略模式的第二种实现方式,目的就是简化策略模式的代码实现。

    2. Lambda表达式的语法

    Lambda表达式用于表示一个函数,所以它和函数一样,也拥有参数、返回值、函数体,但它没有函数名,所以Lambda表达式相当于一个匿名函数。语法如下:

    (Person person)—>person.getAge()>30
    

    Lambda表达式用—>连接,->左侧为函数的参数,->右侧为函数体。
    若右侧由多条语句构成则需要用{}包裹,如:

    (Person person)—>{person.getAge()>30;System.out.println(person.getName());}
    

    Lambda表达式无需显示指定返回值类型,JVM会根据->右侧语句的返回结果自动判断返回值类型,如:

    (Person person)—>person.getAge()>30 #自动判断返回值为boolean型
    

    3. 如何使用Lambda表达式?

    仍以筛选年龄大于30的Person对象为例:

    3.1 为Lambda表达式定义函数式接口

    @FunctionalInterface
    interface FilterProcessor<T>{
        boolean process(T t);
    }
    

    PS:该接口只能有一个抽象函数!接下来Lambda表达式就是该抽象函数的实现。
    PS:在为Lambda表达式定义函数式接口时,需要加上注解@FunctionalInterface,这样当该接口中抽象函数个数不是1时就会报错提示。

    3.2 实现筛选函数

    List<T> filter(List<T> list, FilterProcessor<T> filterProcessor){
        List<T> result = new ArrayList<T>();
        if(filterProcessor.process(t))
            result.add(t);
        return result;
    }
    

    filter函数接收一个函数式接口,该参数用于接收一个Lambda表达式。

    3.3 传递Lambda表达式

    List<Person> result = filter(list, (Person p)->p.getAge()>30);
    

    直接将Lambda表达式作为参数传递给filter的函数式接口即可,从而在result中就能获取年龄超过30岁的Person对象。

    4. 流的基本概念

    4.1 啥是流?

    流是Java8引入的全新概念,它用来处理集合中的数据,暂且可以把它理解为一种高级集合。

    众所周知,集合操作非常麻烦,若要对集合进行筛选、投影,需要写大量的代码,而流是以声明的形式操作集合,它就像SQL语句,我们只需告诉流需要对集合进行啥操作,它就会自动进行操作,并将执行结果交给你,无需我们自己手写代码。

    因此,流的集合操作对我们来说是透明的,我们只需向流下达命令,它就会自动把我们想要的结果给我们。由于操作过程完全由Java处理,因此它可以根据当前硬件环境选择最优的方法处理,我们也无需编写复杂又容易出错的多线程代码了。

    4.2 流的特点

    1. 只能遍历一次
      我们可以把流想象成一条流水线,流水线的源头是我们的数据源(一个集合),数据源中的元素依次被输送到流水线上,我们可以在流水线上对元素进行各种操作。一旦元素走到了流水线的另一头,那么这些元素就被“消费掉了”,我们无法再对这个流进行操作。当然,我们可以从数据源那里再获得一个新的流重新遍历一遍。
    2. 采用内部迭代方式
      若要对集合进行处理,则需我们手写处理代码,这就叫做外部迭代。而要对流进行处理,我们只需告诉流我们需要啥结果,处理过程由流自行完成,这就称为内部迭代。

    4.3 流的操作种类

    流的操作分为两种,分别为中间操作 和 终端操作。

    1. 中间操作
      当数据源中的数据上了流水线后,这个过程对数据进行的所有操作都称为“中间操作”。
      中间操作仍然会返回一个流对象,因此多个中间操作可以串连起来形成一个流水线。
    2. 终端操作
      当所有的中间操作完成后,若要将数据从流水线上拿下来,则需要执行终端操作。
      终端操作将返回一个执行结果,这就是你想要的数据。

    4.4 流的操作过程

    使用流一共需要三步:

    1. 准备一个数据源
    2. 执行中间操作
      中间操作可以有多个,它们可以串连起来形成流水线。
    3. 执行终端操作
      执行终端操作后本次流结束,你将获得一个执行结果。

    5. 流的使用

    5.1 获取流

    在使用流之前,首先需要拥有一个数据源,并通过StreamAPI提供的一些方法获取该数据源的流对象。数据源可以有多种形式:

    • 集合
      这种数据源较为常用,通过stream()方法即可获取流对象:
    List<Person> list = new ArrayList<Person>(); 
    Stream<Person> stream = list.stream();
    
    • 数组
      通过Arrays类提供的静态函数stream()获取数组的流对象:
    String[] names = {"chaimm","peter","john"};
    Stream<String> stream = Arrays.stream(names);
    

    • 直接将几个值变成流对象:
    Stream<String> stream = Stream.of("chaimm","peter","john");
    
    • 文件
    try(Stream<String> lines = Files.lines(Paths.get("文件路径名"),Charset.defaultCharset())){
    //可对lines做一些操作
    }catch(IOException e){
    }

    PS:Java7简化了IO操作,把打开IO操作放在try后的括号中即可省略关闭IO的代码。

    5.2 筛选filter

    filter函数接收一个Lambda表达式作为参数,该表达式返回boolean,在执行过程中,流将元素逐一输送给filter,并筛选出执行结果为true的元素。
    如,筛选出所有学生:

    List<Person> result = list.stream()
                        .filter(Person::isStudent)
                        .collect(toList());
    

    5.3 去重distinct

    去掉重复的结果:

    List<Person> result = list.stream()
                        .distinct()
                        .collect(toList());
    

    5.4 截取

    截取流的前N个元素:

    List<Person> result = list.stream()
                        .limit(3)
                        .collect(toList());
    

    5.5 跳过

    跳过流的前n个元素:

    List<Person> result = list.stream()
                        .skip(3)
                        .collect(toList());
    

    5.6 映射

    对流中的每个元素执行一个函数,使得元素转换成另一种类型输出。流会将每一个元素输送给map函数,并执行map中的Lambda表达式,最后将执行结果存入一个新的流中。
    如,获取每个人的姓名(实则是将Perosn类型转换成String类型):

    List<Person> result = list.stream()
                        .map(Person::getName)
                        .collect(toList());
    

    5.7 合并多个流

    例:列出List中各不相同的单词,List集合如下:
    List<String> list = new ArrayList<String>();
    list.add("I am a boy");
    list.add("I love the girl");
    list.add("But the girl loves another girl");
    

    思路如下:

    • 首先将list变成流:
    list.stream();
    
    • 按空格分词:
    list.stream()
                .map(line->line.split(" "));
    

    分完词之后,每个元素变成了一个String[]数组。

    • 将每个String[]变成流:
    list.stream()
                .map(line->line.split(" "))
                .map(Arrays::stream)
    

    此时一个大流里面包含了一个个小流,我们需要将这些小流合并成一个流。

    • 将小流合并成一个大流:
      用flagmap替换刚才的map
    list.stream()
                .map(line->line.split(" "))
                .flagmap(Arrays::stream)
    
    • 去重
    list.stream()
                .map(line->line.split(" "))
                .flagmap(Arrays::stream)
                .distinct()
                .collect(toList());
    

    5.8 是否匹配任一元素:anyMatch

    anyMatch用于判断流中是否存在至少一个元素满足指定的条件,这个判断条件通过Lambda表达式传递给anyMatch,执行结果为boolean类型。
    如,判断list中是否有学生:

    boolean result = list.stream()
                .anyMatch(Person::isStudent);
    

    5.9 是否匹配所有元素:allMatch

    allMatch用于判断流中的所有元素是否都满足指定条件,这个判断条件通过Lambda表达式传递给anyMatch,执行结果为boolean类型。
    如,判断是否所有人都是学生:

    boolean result = list.stream()
                .allMatch(Person::isStudent);
    

    5.10 是否未匹配所有元素:noneMatch

    noneMatch与allMatch恰恰相反,它用于判断流中的所有元素是否都不满足指定条件:

    boolean result = list.stream()
                .noneMatch(Person::isStudent);
    

    5.11 获取任一元素findAny

    findAny能够从流中随便选一个元素出来,它返回一个Optional类型的元素。

    Optional<Person> person = list.stream()
                                        .findAny();
    

    Optional介绍

    Optional是Java8新加入的一个容器,这个容器只存1个或0个元素,它用于防止出现NullpointException,它提供如下方法:

    • isPresent()
      判断容器中是否有值。
    • ifPresent(Consume<T> lambda)
      容器若不为空则执行括号中的Lambda表达式。
    • T get()
      获取容器中的元素,若容器为空则抛出NoSuchElement异常。
    • T orElse(T other)
      获取容器中的元素,若容器为空则返回括号中的默认值。

    5.12 获取第一个元素findFirst

    Optional<Person> person = list.stream()
                                        .findFirst();
    

    5.13 归约

    归约是将集合中的所有元素经过指定运算,折叠成一个元素输出,如:求最值、平均数等,这些操作都是将一个集合的元素折叠成一个元素输出。

    在流中,reduce函数能实现归约。
    reduce函数接收两个参数:

    • 初始值
    • 进行归约操作的Lambda表达式

    5.13.1 元素求和:自定义Lambda表达式实现求和

    例:计算所有人的年龄总和

    int age = list.stream().reduce(0, (person1,person2)->person1.getAge()+person2.getAge());
    

    reduce的第一个参数表示初试值为0;
    reduce的第二个参数为需要进行的归约操作,它接收一个拥有两个参数的Lambda表达式,reduce会把流中的元素两两输给Lambda表达式,最后将计算出累加之和。

    5.13.2 元素求和:使用Integer.sum函数求和

    上面的方法中我们自己定义了Lambda表达式实现求和运算,如果当前流的元素为数值类型,那么可以使用Integer提供了sum函数代替自定义的Lambda表达式,如:

    int age = list.stream().reduce(0, Integer::sum);
    

    Integer类还提供了min、max等一系列数值操作,当流中元素为数值类型时可以直接使用。

    5.14 数值流的使用

    采用reduce进行数值操作会涉及到基本数值类型和引用数值类型之间的装箱、拆箱操作,因此效率较低。
    当流操作为纯数值操作时,使用数值流能获得较高的效率。

    5.14.1 将普通流转换成数值流

    StreamAPI提供了三种数值流:IntStream、DoubleStream、LongStream,也提供了将普通流转换成数值流的三种方法:mapToInt、mapToDouble、mapToLong。
    如,将Person中的age转换成数值流:

    IntStream stream = list.stream()
                                .mapToInt(Person::getAge);
    

    5.14.2 数值计算

    每种数值流都提供了数值计算函数,如max、min、sum等。
    如,找出最大的年龄:

    OptionalInt maxAge = list.stream()
                                    .mapToInt(Person::getAge)
                                    .max();
    

    由于数值流可能为空,并且给空的数值流计算最大值是没有意义的,因此max函数返回OptionalInt,它是Optional的一个子类,能够判断流是否为空,并对流为空的情况作相应的处理。
    此外,mapToInt、mapToDouble、mapToLong进行数值操作后的返回结果分别为:OptionalInt、OptionalDouble、OptionalLong

    6. 收集器简介

    收集器用来将经过筛选、映射的流进行最后的整理,可以使得最后的结果以不同的形式展现。

    collect方法即为收集器,它接收Collector接口的实现作为具体收集器的收集方法。

    Collector接口提供了很多默认实现的方法,我们可以直接使用它们格式化流的结果;也可以自定义Collector接口的实现,从而定制自己的收集器。

    这里先介绍Collector常用默认静态方法的使用,自定义收集器会在下一篇博文中介绍。

    7. 收集器的使用

    7.1 归约

    流由一个个元素组成,归约就是将一个个元素“折叠”成一个值,如求和、求最值、求平均值都是归约操作。

    7.1.1 计数

    long count = list.stream()
                        .collect(Collectors.counting());
    

    也可以不使用收集器的计数函数:

    long count = list.stream().count();
    

    注意:计数的结果一定是long类型。

    7.1.2 最值

    例:找出所有人中年龄最大的人
    Optional<Person> oldPerson = list.stream()
                        .collect(Collectors.maxBy(Comparator.comparingInt(Person::getAge)));
    

    计算最值需要使用Collector.maxBy和Collector.minBy,这两个函数需要传入一个比较器Comparator.comparingInt,这个比较器又要接收需要比较的字段。
    这个收集器将会返回一个Optional类型的值。

    7.1.3 求和

    例:计算所有人的年龄总和
    int summing = list.stream()
                        .collect(Collectors.summingInt(Person::getAge));
    

    当然,既然Java8提供了summingInt,那么还提供了summingLong、summingDouble。

    7.1.4 求平均值

    例:计算所有人的年龄平均值
    double avg = list.stream()
                        .collect(Collectors.averagingInt(Person::getAge));
    

    注意:计算平均值时,不论计算对象是int、long、double,计算结果一定都是double。

    7.1.5 一次性计算所有归约操作

    Collectors.summarizingInt函数能一次性将最值、均值、总和、元素个数全部计算出来,并存储在对象IntSummaryStatisics中。
    可以通过该对象的getXXX()函数获取这些值。

    7.1.6 连接字符串

    例:将所有人的名字连接成一个字符串
    String names = list.stream()
                            .collect(Collectors.joining());
    

    每个字符串默认分隔符为空格,若需要指定分隔符,则在joining中加入参数即可:

    String names = list.stream()
                            .collect(Collectors.joining(", "));
    

    此时字符串之间的分隔符为逗号。

    7.1.7 一般性的归约操作

    若你需要自定义一个归约操作,那么需要使用Collectors.reducing函数,该函数接收三个参数:

    • 第一个参数为归约的初始值
    • 第二个参数为归约操作进行的字段
    • 第三个参数为归约操作的过程
    例:计算所有人的年龄总和
    Optional<Integer> sumAge = list.stream()
                                        .collect(Collectors.reducing(0,Person::getAge,(i,j)->i+j));
    

    上面例子中,reducing函数一共接收了三个参数:

    • 第一个参数表示归约的初始值。我们需要累加,因此初始值为0
    • 第二个参数表示需要进行归约操作的字段。这里我们对Person对象的age字段进行累加。
    • 第三个参数表示归约的过程。这个参数接收一个Lambda表达式,而且这个Lambda表达式一定拥有两个参数,分别表示当前相邻的两个元素。由于我们需要累加,因此我们只需将相邻的两个元素加起来即可。

    Collectors.reducing方法还提供了一个单参数的重载形式。
    你只需传一个归约的操作过程给该方法即可(即第三个参数),其他两个参数均使用默认值。

    • 第一个参数默认为流的第一个元素
    • 第二个参数默认为流的元素
      这就意味着,当前流的元素类型为数值类型,并且是你要进行归约的对象。
    例:采用单参数的reducing计算所有人的年龄总和
    Optional<Integer> sumAge = list.stream()
                .filter(Person::getAge)
                .collect(Collectors.reducing((i,j)->i+j));
    

    7.2 分组

    分组就是将流中的元素按照指定类别进行划分,类似于SQL语句中的GROUPBY。

    7.2.1 一级分组

    例:将所有人分为老年人、中年人、青年人
    Map<String,List<Person>> result = list.stream()
                                        .collect(Collectors.groupingby((person)->{
            if(person.getAge()>60)
                return "老年人";
            else if(person.getAge()>40)
                return "中年人";
            else
                return "青年人";
                                        }));
    

    groupingby函数接收一个Lambda表达式,该表达式返回String类型的字符串,groupingby会将当前流中的元素按照Lambda返回的字符串进行分组。
    分组结果是一个Map< String,List< Person>>,Map的键就是组名,Map的值就是该组的Perosn集合。

    7.2.2 多级分组

    多级分组可以支持在完成一次分组后,分别对每个小组再进行分组。
    使用具有两个参数的groupingby重载方法即可实现多级分组。

    • 第一个参数:一级分组的条件
    • 第二个参数:一个新的groupingby函数,该函数包含二级分组的条件
    例:将所有人分为老年人、中年人、青年人,并且将每个小组再分成:男女两组。
    Map<String,Map<String,List<Person>>> result = list.stream()
                                        .collect(Collectors.groupingby((person)->{
            if(person.getAge()>60)
                return "老年人";
            else if(person.getAge()>40)
                return "中年人";
            else
                return "青年人";
                                        },
                                        groupingby(Person::getSex)));
    

    此时会返回一个非常复杂的结果:Map< String,Map< String,List< Person>>>。

    7.2.3 对分组进行统计

    拥有两个参数的groupingby函数不仅仅能够实现多几分组,还能对分组的结果进行统计。

    例:统计每一组的人数
    Map<String,Long> result = list.stream()
                                        .collect(Collectors.groupingby((person)->{
            if(person.getAge()>60)
                return "老年人";
            else if(person.getAge()>40)
                return "中年人";
            else
                return "青年人";
                                        },
                                        counting()));
    

    此时会返回一个Map< String,Long>类型的map,该map的键为组名,map的值为该组的元素个数。

    将收集器的结果转换成另一种类型

    当使用maxBy、minBy统计最值时,结果会封装在Optional中,该类型是为了避免流为空时计算的结果也为空的情况。在单独使用maxBy、minBy函数时确实需要返回Optional类型,这样能确保没有空指针异常。然而当我们使用groupingBy进行分组时,若一个组为空,则该组将不会被添加到Map中,从而Map中的所有值都不会是一个空集合。既然这样,使用maxBy、minBy方法计算每一组的最值时,将结果封装在optional对象中就显得有些多余。
    我们可以使用collectingAndThen函数包裹maxBy、minBy,从而将maxBy、minBy返回的Optional对象进行转换。

    例:将所有人按性别划分,并计算每组最大的年龄。
    Map<String,Integer> map = list.stream()
                                .collect(groupingBy(Person::getSex,
                                collectingAndThen(
                                maxBy(comparingInt(Person::getAge)),
                                Optional::get
                                )));
    

    此时返回的是一个Map< String,Integer>,String表示每组的组名(男、女),Integer为每组最大的年龄。
    如果不用collectingAndThen包裹maxBy,那么最后返回的结果为Map<String,Optional<Person>>。
    使用collectingAndThen包裹maxBy后,首先会执行maxBy函数,该函数执行完后便会执行Optional::get,从而将Optional中的元素取出来。

    7.3 分区

    分区是分组的一种特殊情况,它只能分成true、false两组。
    分组使用partitioningBy方法,该方法接收一个Lambda表达式,该表达是必须返回boolean类型,partitioningBy方法会将Lambda返回结果为true和false的元素各分成一组。
    partitioningBy方法返回的结果为Map<Boolean,List<T>>。
    此外,partitioningBy方法和groupingBy方法一样,也可以接收第二个参数,实现二级分区或对分区结果进行统计。

    如果以下文章过于晦涩难懂的话,建议诸位可以看看此套教程:https://4m.cn/37UKQ 。

     

  • 相关阅读:
    CPU深度学习模型推理性能抖动问题
    深度学习推理性能优化
    Winograd Convolution 推导
    Res-Family: From ResNet to SE-ResNeXt
    CPU二则
    CPU TFLOPS 计算
    深度学习专题
    计算系统中互联设备Survey
    深度学习框架演进史
    天池医疗AI大赛支持有感
  • 原文地址:https://www.cnblogs.com/bjcoder/p/14068900.html
Copyright © 2011-2022 走看看