JDK1.8的新特性

来源:http://www.prospettivedarte.com 作者:计算机教程 人气:59 发布时间:2019-05-31
摘要:前言 以前大致了解过jdl1.8的一些新特性,长时间不用,慢慢忘记了,最近又捡起来看了下,并参考了一些博客,有些许新的收获,特此记录下。 参考博客: https://blog.csdn.net/chengwangba

前言

以前大致了解过jdl1.8的一些新特性,长时间不用,慢慢忘记了,最近又捡起来看了下,并参考了一些博客,有些许新的收获,特此记录下。

参考博客: https://blog.csdn.net/chengwangbaiko/article/details/73433645

一、简介

  • lambda表达式是Java8的新特性之一,它将允许我们将行为传到函数里。在Java 8之前,如果想将行为传入函数,仅有的选择就是匿名类,需要6行代码。而定义行为最重要的那行代码,却混在中间不够突出。Lambda表达式取代了匿名类,取消了模板,允许用函数式风格编写代码。这样有时可读性更好,表达更清晰。在Java生态系统中,函数式表达与对面向对象的全面支持是个激动人心的进步。
  • “Lambda 表达式”(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象(lambda abstraction),是一个匿名函数,即没有函数名的函数。Lambda表达式可以表示闭包(注意和数学传统意义上的不同)。

正文

关于1.8的一些新特性,会仔细研究过之后慢慢进行更新。

二、语法

  1. Lambda语法:
    (parameters)->expression 或者 (parameters)->{statements;}
  2. Lambda表达式由三部分组成:
  • parameters:类似方法中的形参列表,这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断,当只有一个推断类型时可以省略掉圆括号。
  • -> :可以理解为“被用于”的意思。
  • 方法体:可以是表达式也可以是代码块,实现函数式接口中的方法。这个方法体可以有返回值也可以没有返回值。
  1. 传统写法与Lambda写法的比较:
    //传统方式使用接口
    Transform<String ,Integer> transform1 = new Transform<String, Integer>() {
        @Override
        public Integer transform(String s) {
            return Integer.valueOf(s);
        }
    } ;

    //Lambda方式使用接口,就是这么简单粗暴,没脾气
    Transform<String,Integer> transform2 = (s)-> Integer.valueOf(s);

 1. 接口的扩展方法

在jdk1.8之前,接口中只允许有抽象方法,但是在1.8之后,接口中允许有一个非抽象的方法,但是必须使用default进行修饰,叫做扩展方法。

public interface UserService {

    void deleteUser(User user);

    default User showUser(User user){
        System.out.println("show User");
        user = Optional.ofNullable(user).orElse(new User());
        user.setName("这是经过扩展方法之后的user");
        return user;
    }
}

在我们实现接口之后,可以选择对方法直接使用或者重写。

三、访问权限

  1. 在Lambda表达式使用中,Lambda表达式外面的局部变量会被JVM隐式的编译成final类型,Lambda表达式内部只能访问,不能修改。
  2. Lambda表达式内部对静态变量和成员变量是可读可写的。
  3. Lambda不能访问函数接口的默认方法,在函数接口中可以添加default关键字定义默认的方。

局部变量示例:

 public static void main(String[] args) {
        int num = 6;//局部变量
        Sum sum = value -> {
//            num = 8; 这里会编译出错
            return num   value;
        };
        sum.add(8);
    }

    /**
     * 函数式接口
     */
    @FunctionalInterface
    interface Sum{
        int add(int value);
    }

静态变量和成员变量示例:

 public int num1 = 6;
    public static int num2 = 8;
    private int getSum(){
        Sum sum = value -> {
            num1 = 10;
            num2 = 10;
            return  num1   num2;
        };
        return sum.add(1);
    }

    /**
     * 函数式接口
     */
    @FunctionalInterface
    interface Sum{
        int add(int value);
    }

2. 函数式接口,方法与构造方法的引用

函数式接口:接口中只有一个方法,可以对应一个lambda表达式。通过匿名内部类或者方法传递进行连接,调用接口即调用对应的方法。

@FunctionalInterface
public interface Converter<F,T> {
    T converter(F f);
}
//方法传递,使用的是Integer.valueOf()的方法
Converter<String ,Integer> converter = Integer::valueOf;

四、方法引用

  1. 在lambda表达式中,方法引用是一种简化写法,引用的方法就是Lambda表达式的方法体的实现 。
  2. 语法结构:ObjectRef:: methodName
    左边是类名或者实例名,中间的“::”是方法引用符号,右边是相应的方法名 。
  3. 方法引用一般分为三类:
    静态方法引用,实例方法引用,构造方法引用。
public static void main(String[] args){
        //传统方式
        Transform<String ,Integer> transform1 = new Transform<String, Integer>() {
            @Override
            public Integer transform(String s) {
                return new Obj().strToInt(s);
            }
        };
        int result1 = transform1.transform("100");
        //Lambda方式
        Obj obj = new Obj();
        Transform<String,Integer> transform2 = obj::strToInt;
        int result2 = transform2.transform("200");
    }
    /**
     * 函数式接口
     * @param <A>
     * @param <B>
     */
    interface Transform<A,B>{
        B transform(A a);
    }
    /**
     * 实例对象类
     */
    static class Obj{
        public int strToInt(String str){
            return Integer.valueOf(str);
        }
    }

3. 其余的一些接口:

五、四个常用的接口

Predicate接口

/**
 * Predicate接口:输入一个参数,返回一个boolean值,内置了许多用于逻辑判断的默认方法
 */
public class F_实践之Predicate {
    public void predicateTest(){
        Predicate<String> predicateStr = s -> s.length()>8;
        boolean testResult = predicateStr.test("test");//需要api 24
        testResult = predicateStr.negate().test("test");//取反,也就是s.length<=8

        Predicate<Object> predicateObj = Objects::nonNull;
        Object obj = null;
        testResult = predicateObj.test(obj);//判断是否为空
    }
}

Consumer接口

/**
 * consumer接口:对输入的参数进行操作。有输入没输出
 */
  private static void consumerTest(){
        Consumer<Integer> add5 = (p) -> {
            System.out.println("old value:"   p);
            p = p   5;
            System.out.println("new value:"   p);
        };
        add5.accept(10);
    }

Function接口

/**
 * Function接口:接受一个参数,返回单一的结果。默认的方法(andThen)可将多个函数串在一起,形成复合Funtion(有输入,有输出)结果
 */
  public static void functionTest(){
        Function<String, Integer> toInteger = Integer::valueOf;
        //toInteger的执行结果作为第二个backToString的输入
        Function<String, String> backToString = toInteger.andThen(String::valueOf);
        String result = backToString.apply("1234");
        System.out.println(result);

        Function<Integer, Integer> add = (i) -> {
            System.out.println("frist input:"   i);
            return i * 2;
        };
        Function<Integer, Integer> zero = add.andThen((i) -> {
            System.out.println("second input:"   i);
            return i * 0;
        });

        Integer res = zero.apply(8);
        System.out.println(res);
    }

Supplier接口

/**
 * Supplier接口:返回一个给定类型的结果。不需要输入参数,无输入有输出
 */
   private static void supplierTest(){
        Supplier<String> supplier = () -> "我就是输出";
        String s = supplier.get();
        System.out.println(s);
    }

3.1:Predicate<T>接口:

  接口只有一个参数,返回boolean类型。该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑(比如:与,或,非):

public static void main(String[] args) {
        //定义函数式接口,需要注意的是:Predicate接口指向方法的时候,指向的必须是返回值为boolean类型的方法。
        Predicate<String> predicate = s -> s.length() < 1; //定义函数式接口
        Predicate<String> predicate2 = Objects::nonNull;
        //Predicate接口的and方法,表示与。negative()表示的是否,or()表示的是或
        System.out.println(predicate2.test("ssss"));                //true
        System.out.println(predicate.and(predicate2).test("sss"));  //false
        System.out.println(predicate.or(predicate2).test("sss"));   //true
    }

六、Steam管道操作

  1. Lambda为java8带来了闭包,支持对集合对象的stream进行函数式操作, stream api被集成进了collection api ,允许对集合对象进行批量操作。
  2. Stream表示数据流,它没有数据结构,本身也不存储元素,其操作也不会改变源Stream,而是生成新Stream.作为一种操作数据的接口,它提供了过滤、排序、映射、规约等多种操作方法,
  3. 这些方法按照返回类型被分为两类:凡是返回Stream类型的方法,称之为中间方法(中间操作),其余的都是完结方法(完结操作)。完结方法返回一个某种类型的值,而中间方法则返回新的Stream。
  4. 中间方法的调用通常是链式的,该过程会形成一个管道,当完结方法被调用时会导致立即从管道中消费值,这里我们要记住:Stream的操作尽可能以“延迟”的方式运行,也就是我们常说的“懒操作”,
  5. 这样有助于减少资源占用,提高性能。对于所有的中间操作(除sorted外)都是运行在延迟模式下。
  6. Stream不但提供了强大的数据操作能力,更重要的是Stream既支持串行也支持并行,并行使得Stream在多核处理器上有着更好的性能。
  7. Stream的使用过程有着固定的模式:
    1.创建Stream
    2.通过中间操作,对原始Stream进行“变化”并生成新的Stream
    3.使用完结操作,生成最终结果

中间操作方法

  1. 过滤(filter)
    结合Predicate接口,Filter对流对象中的所有元素进行过滤,该操作是一个中间操作,这意味着你可以在操作返回结果的基础上进行其他操作
 public static void sreamFilterTest(List<String> lists){ //要明确这list的泛型类型,否则jvm不能根据上下文确定参数类型
        lists.stream().filter((s -> s.startsWith("a"))).forEach(System.out::println);//将开头是a的过滤出来

        //等价于以上操作
        Predicate<String> predicate = (s) -> s.startsWith("a");//将开头是a的过滤出来
        lists.stream().filter(predicate).forEach(System.out::println);

        //连续过滤
        Predicate<String> predicate1 = (s -> s.endsWith("1"));//将开头是a,并且结尾是1的过滤出来
        lists.stream().filter(predicate).filter(predicate1).forEach(System.out::println);
    }
  1. 排序(sorted)
    结合Comparator,该操作返回一个排序过后的流的视图,原始流的顺序不会改变。通过Comparator来指定排序规则,默认是自然排序
 private static void streamSortedTest(List<String> list){
        //默认排序
        list.stream().filter(s -> s.startsWith("a")).forEach(System.out::println);
        System.out.println("- - - - - - - - -");
        //自定义排序
        list.stream().sorted(((s, t1) -> t1.compareTo(s))).filter(s -> s.startsWith("a")).forEach(System.out::println);
    }
  1. 映射(map)
    结合Function接口,该操作能将流对象中的每一个元素映射为另一个元素,实现元素类型的转换。
 private static void streamMapTest(List<String> list){
        list.stream().map(String::toUpperCase).sorted((s, t1) -> t1.compareTo(s)).forEach(System.out::println);
        System.out.println("- - - - - - ");
        //自定义映射规则
        Function<String,String> function = s -> {return  s   ".map3";};
        list.stream().map(function).forEach(System.out::println);
    }

完结操作方法

  1. 匹配(match)
    用来判断某个predicate是否和流对象相匹配,最终返回boolean类型的结果
 private static void streamMatchTest(List<String> list){
        //流对象中只要有一个元素匹配就返回true
        boolean anyStartWithA = list.stream().anyMatch(s -> s.startsWith("a"));
        System.out.println("集合中是否有以'a'来头:"  anyStartWithA);
        //流对象中每一个元素都匹配才返回true
        boolean allStartWithA = list.stream().allMatch(s -> s.startsWith("a"));
        System.out.println("集合中每一个都是以'a'开头:"  allStartWithA);
        //流对象中没有匹配时返回true
        boolean noneStartWithA = list.stream().noneMatch(s -> s.startsWith("c"));
        System.out.println("集合中没有以'c'开头:"  noneStartWithA);
    }
  1. 收集(collect)
    在对经过变换后,将变换的stream元素收集,比如将这些元素存在集合中,可以使用stream提供的collect方法
 private static void streamCollectTest(List<String> list){
        List<String> listNew = list.stream().filter(s -> s.startsWith("b")).sorted().collect(Collectors.toList());
        System.out.println(listNew );
    }
  1. 规约(reduce)
    允许我们用自己的方式计算元素或者将一个stream中元素以某种规律关联
private static void streamReduceTest(List<String> list){
        Optional<String> optional = list.stream().sorted().reduce((s, s2) -> {
            System.out.println(s "-" s2);
            return s "-" s2;
        });
    }
  1. 计数(count)
    用来统计流中元素的总数
private static void streamCountTest(List<String> list){
        long count = list.stream().filter(s -> s.startsWith("b")).count();
        System.out.println("以'b'开头的数量:"  count);
    }

3.2 Optional<T>类

  Optional<T>类,继承Object,私有构造,是一个可能包含或不包含非空值的容器对象,如果一个值存在, isPresent()将返回true和get()将返回值。

  想要获取对象可以直接使用一下几种方法:

Optional<T>的静态方法:
1. Optional.empty()-->返回一个空的Optional实例
2. Optional.of(T value) --> 返回一个具有Optional的当前非空值的optional实例,需要注意的是:这里传的应该是非空值。如果可能为空,请用下面的
3. Optional.ofNullable(T value) -->返回一个具有Optional的当前值的optional实例,如果值为空,则返回一个空的Optional实例。

  关于Optional<T>的api,参考jdk1.8的API文档。

  Optional<T>的一些应用实例:

1. 结合stream进行使用:后面详细说
2. 单独使用:Optional.ofNullable(user.getUserName()).orElse("hello,name is null").toString(); 
//解释下:如果你数据库查询出的user的name字段未知,你要进行null判断,如果未null,则显示为“hello,name is null” 进行返回。toString是为了查询到的name不是String的时候进行转换。

3.2 Function接口、Supplier 接口、Consumer 接口等

  这些接口均是和lambda表达式进行配合,其中Function可以进行多个lambda的组合。

  (具体的详情可以参见:jdk1.8的api文档)

4. lamdba表达式的用法

4.1创建匿名内部类

  在1.8之前,我们创建匿名内部类的时候,是这样的:

 Converter<String ,Integer> converter = new Converter<String, Integer>() {
        @Override
        public Integer converter(String s) {
            return Integer.parseInt(s);
        }
    };

  在1.8之后呢,我们可以这样来创建

Converter<String ,Integer> converter = (f) -> {
        return Integer.valueOf(f);
    };

  更简单的:如果你的方法体只有一句的话,你可以这样来创建

Converter<String ,Integer> converter = (f) -> Integer.parseInt(f);

 4.2 lambda表达式和Stream接口对集合的操作《重点》

  1. Stream类似于流,单向,不可往复。可以对集合的所有元素进行筛选,过滤,修改等,但是只能对数据遍历一次,如果需要第二次操作,必须继续创建Stream流。

  2. Stream操作分为三个步骤:创建Stream--》中间操作--》最终操作。

本文由皇牌天下投注网发布于计算机教程,转载请注明出处:JDK1.8的新特性

关键词:

上一篇:Mysql服务器的启动与停止(二)

下一篇:没有了

最火资讯