JDK8及以后的新特性

最新推荐文章于 2024-07-24 06:12:13 发布

爪哇哇哇哇

最新推荐文章于 2024-07-24 06:12:13 发布

阅读量181

点赞数

分类专栏： JAVA基础文章标签：开发语言

本文链接：https://blog.csdn.net/yd1472939313/article/details/132303971

版权

JAVA基础专栏收录该内容

37 篇文章 0 订阅

订阅专栏

一、Jdk8新增lambda表达式

1.Lambda表达式的使用举例

@Test
    public void test1(){
        //--------------Lambda优化前--------------
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1 , o2);
            }
        };

        int compare = com.compare(3, 4);
        System.out.println(compare);

        //--------------Lambda优化后--------------
        Comparator<Integer> com2 = (o1 , o2) -> Integer.compare(o1 , o2);
        int compare1 = com2.compare(4, 3);
        System.out.println(compare1);
    }

2.Lambda表达式的格式举例：

lambda形参列表 ->lambda体

3.lambda表达式的格式

-> : lambda操作符或箭头操作符
->的左边：lambda形参列表，对应着要重写接口中的抽象方法的形参列表。
->的右边：lambda体：对应着接口的实现类要重写的方法的方法体。

4.lambda表达式的本质：

一方面，lambda表达式作为接口的实现类的对象。
另一方面，lambda表达式是一个匿名函数。

5.函数式接口

什么是函数式接口?为什么需要函数式接口?

如果接口中只声明有一个抽象方法，则此接口就称为函数式接口。
因为只有给函数式接口提供实现类的对象时，我们才可以使用Lambda表达式

api中函数式接口所在的包：

java.util.function下

4个基本的函数式接口

消费型接口

Consumer< T> void accept(T t);

供给型接口

Supplier< T> T get();

函数型接口

Function< T , R> R apply(T t);

判断型接口

Predicat< T> boolean test(T t);

6.Lambda表达式的语法规则总结

->的左边：Lambda形参列表，参数的类型都可以省略。如果形参只有一个，则一对()也可以省略。
->的右边：Lambda体，对应着重写的方法的方法体。如果方法体中只有一行执行语句，则一对子可以省略。如果有return关键字，则必须一并省略。

二、方法引用

1.方法引用的理解

方法引用，可以看作是基于lamda表达式的进一步刻画
当需要提供一个函数式接口的实例时，我们可以使用lambda表达式提供此实例
当满足一定的条件的情况下，我们还可以使用方法引用或构造器引用替换lambda表达式

2.方法引用的本质

方法引用作为了函数式接口的实例。

3.格式：

类(或对象) :: 方法名

4.具体使用情况说明：

情况1：对象 :: 实例方法

要求：函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的形参列表和返回值类型都相同。此时，可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。
注意：此方法b是非静态方法，需要对象调用。

@Test
    public void test2(){
        //1.传统实现：
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("hello");
        //2.lambda表达式：
        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("hello");

        //3.方法引用：
        Consumer<String> con2 = System.out :: println;
        con2.accept("hello");
    }

情况2：对象 :: 静态方法

要求：函数式接口中的抽象方法a与其内部实现时调用的对象的某个静态方法b的形参列表和返回值类型都相同。此时，可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。
注意：此方法b是静态方法，需要类调用。

@Test
    public void test3(){
        //1.传统实现：
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1 , o2);
            }
        };
        com.compare(1,2);
        //2.lambda表达式：
        Comparator<Integer> com1 = (o1 , o2) -> Integer.compare(o1 , o2);
        com1.compare(1,2);

        //3.方法引用：
        Comparator<Integer> com2 = Integer :: compare;
        System.out.println(com2.compare(1, 2));
    }

情况3：类 :: 实例方法

函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的返回值类型相同。同时，抽象方法a中有n个参数，方法b中有n-1个参数，且抽象方法a的第1个参数作为方法b的调用者，且抽象方法a的后n-1个参数与方法b的n-1个参数的类型相同(或一致)。则可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意：此方法b是非静态方法，需要对象调用。

@Test
    public void test4(){
        //1.传统实现：
        Comparator<String> com = new Comparator<>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(com.compare("a", "b"));
        //2.lambda表达式：
        Comparator<String> com1 = (o1 , o2) -> o1.compareTo(o2);
        System.out.println(com1.compare("a", "b"));

        //3.方法引用：
        Comparator<String> com2 = String :: compareTo;
        System.out.println(com2.compare("b", "a"));
    }