Java8新特性:Lambda表达式、函数式接口、方法引用 、 构造器引用 和 数组引用

1、Lambda表达式

Lambda是一个匿名函数,我们可以把 Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。

使用它可以写出更简洁、更灵活的代码。作为一种更紧读的代码风格,使Java的语言表达能力得到了提升。

1.1使用举例

@Test
    public void test02(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        int compare1 = com1.compare(21,32);//-1
        System.out.println(compare1);

        System.out.println("******使用Lambda***********");

        //Lambda表达式
        Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1, o2);
        int compare2 = com2.compare(21,12);//1
        System.out.println(compare2);

        //方法引用

        Comparator<Integer> com3 = Integer :: compare;
        int compare3 = com3.compare(21,12);//1
        System.out.println(compare2);


    }

1.2 Lambda表达式语法

/**
 * @Author 孑然
 *
 * Lambda表达式的使用
 *
 * 1.举例:(o1, o2) -> Integer.compare(o1, o2);
 * 2.格式:
 *      -> : Lambda操作符 或 箭头操作符
 *      ->左边:Lambda形参列表(其实就是接口中的抽象方法的形参列表)
 *      ->右边:Lambda体 (其实就是重写的抽象方法的方法体)
 *
 * 3. Lambda表达式的使用:6种情况
 *
 *
 * 4. Lambda表达式的本质:作为函数式接口的实例
 */

语法格式1:无参, 无返回值

// 语法格式1:无参,无返回值
    @Test
    public void test01(){

        Runnable r1 = new Runnable(){
            @Override
            public void run() {
                System.out.println("你好,我是jack");
            }
        };
        r1.run();
        System.out.println("******使用Lambda***********");

        //使用Lambda表达式
        Runnable r2 = () -> System.out.println("你好,我是张三");
        r2.run();

    }

语法格式2:Lambda需要一个参数,但是没有返回值

//语法格式2:Lambda需要一个参数,但是没有返回值
    @Test
    public void test02(){

        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("世界上最好的语言是什么?");

        //使用Lambda表达式
        Consumer<String> con1 =(String s) -> {
            System.out.println(s);
        };
        con1.accept("是PHP");
    }

语法格式3:数据类型可以省略,因为可由编译器推断,称为类型维护

//语法格式3:数据类型可以省略,因为可由编译器推断,称为类型维护
    @Test
    public void main(){
        //使用Lambda表达式
        Consumer<String> con1 =(s) -> {
            System.out.println(s);
        };
        con1.accept("当然是Java");
    }

语法格式4:Lambda 若只需要一个参数时,参数的小括号可以省略

@Test
    public void test04(){
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("当然是Java");
    }

语法格式5:Lambda需要两个或以上的参数,多条执行语句,并且可以有返回值

@Test
    public void test05(){

        Comparator<Integer> comp = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        //调用
        System.out.println(comp.compare(12, 21));

        //使用Lambda
        Comparator<Integer> comp1 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        //调用
        System.out.println(comp1.compare(12, 6));
    }

语法格式6:当 Lambda 体只有一条语句时,return 与 大括号若有,都可以省略

//语法格式6:当 Lambda 体只有一条语句时,return 与 大括号若有,都可以省略
    @Test
    public void test07(){
        //使用Lambda
        Comparator<Integer> comp1 = (o1, o2) -> 
                o1.compareTo(o2);
        
        //调用
        System.out.println(comp1.compare(12, 6));
    }

1.3 Lambda总结

  1. -> 左边:
    • Lambda形参列表的参数类型可以省略(类型推断)
    • 如果Lambda形参列表只有一个参数,其一对()也可以省略
  2. -> 右边:
    • 如果Lambda体应该使用一对{}包裹
    • 如果Lambda体只有一条执行语句(可能是return语句),可以省略这一对{}和return关键字;
  3. 依赖于函数式接口
  4. 以前用匿名实现类表示的现在都可以用Lambda表达式来写

2、函数式接口

基本介绍:

如果一个接口中,之生命了一个抽象方法,则此接口就称为函数式接口

2.1 自定义函数式接口

注意:

注解@FunctionalInterface,是用来校验当前接口是否为函数式接口,同时javadoc也会包含一条声明,说明这个接口是一个函数式接口

与注解override类似

@FunctionalInterface
public interface MyInterface {

    void method1();
}

2.2 Java内置函数式接口

在java.util.function包下定义了java8的丰富的函数式接口

Java内置四大核心函数是接口:

在这里插入图片描述

在这里插入图片描述

3、方法引用和构造器引用

3.1 方法引用

当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用

要求:要求接口中的抽象方法的 形参列表和返回值类型 与 方法引用的 形参列表和返回值类型 相同!(针对情况1和2)

方法引用,本质上就是Lambda表达式,而Lambda表达式作为函数式接口的实例

所以方法 也是函数接口的实例

使用格式:类(或对象):: 方法名

具体分为如下大的三种情况

  • 情况1:对象 :: 非静态方法
  • 情况2:类 :: 静态方法
  • 情况3:类 :: 非静态方法

情况一:对象 :: 实例方法

 //情况一: 对象 :: 实例方法
    //Consumer中的 void accept(T t)
    //PrintDtream中的 void println(T t)
    @Test
    public void test1(){
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");

        //使用方法引用
        Consumer<String> con2 = System.out::println;
        con2.accept("南京");

    }
    //Supplier 中的 T get()
    //Employee 中的String getName()
    @Test
    public void test02(){
        Employee emp = new Employee(1001, "Tom",23, 5600);

        Supplier<String> sup1 = () -> emp.getName();
        System.out.println(sup1.get());

        //使用方法引用
        Supplier<String> sup2 = emp::getName;
        System.out.println(sup2.get());
    }

情况二:类::静态方法

//情况二:类::静态方法
//Comparator中的 int compare(T t1, T t2)
//Integer中的 int compare(T t1, T t2)
@Test
public void test3(){
    Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
    System.out.println(com1.compare(12,21));
    System.out.println("*************");
    //使用方法引用
    Comparator<Integer> com2 = Integer::compare;
    System.out.println(com2.compare(12,6));
 }
//Function 中的 R apply(T t)
//Math 中的 Long round(Double d)
@Test
public void test4(){
    Function<Double,Long> function1 = d -> Math.round(d);
    System.out.println(function1.apply(1.85));//2

    //使用方法引用
    Function<Double,Long> function2 = Math::round;
    System.out.println(function2.apply(1.25));//1
}

情况三:类 :: 实例方法

//情况三:类 :: 实例方法
    //Comparator 中的int compare(T t1, T t2)
    //String 中的 int t1.compareTo(t2)
    @Test
    public void test5(){
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc", "abd"));

        //使用方法引用
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("bcd", "bca"));
    }
    //BiPredicate 中的 boolean test(T t1, T t2)
    //String 中的 boolean t1.equals(t2)
    @Test
    public void test6(){
        BiPredicate<String,String> pre1 = (s, s2) -> s.equals(s2);
        System.out.println(pre1.test("abc", "abc"));

        //使用方法引用
        BiPredicate<String,String> pre2 = String::equals;//true
        System.out.println(pre2.test("acd", "acd"));//true
    }

3.2 构造器引用

构造器引用

  •  和方法引用类似,函数式接口的 抽象方法的形参列表 和 构造器的 形参列表一致。
    
  •  抽象方法的返回值类型 即为 构造器 所属的类的类型
    
//无参
    //构造器引用
    //Supplier 中的 T get()
    @Test
    public void test1(){

        Supplier<Employee> sup1 = () -> new Employee();
        Employee employee = sup1.get();
        //使用构造器引用
        Supplier<Employee> sup2 = Employee::new;
        Employee employee1 = sup2.get();
    }
    //有参
    //Function 中的 R apply(T t)
    @Test
    public void test2(){
        Function<Integer, Employee> fun1 = id -> new Employee(id);
        Employee employee = fun1.apply(1002);
        System.out.println(employee);

        //使用构造器引用
        Function<Integer, Employee> fun2 = Employee::new;
        Employee employee1 = fun2.apply(1003);
        System.out.println(employee1);
    }
    //有参
    //BiFunction 中的 R apply(T t, U u)
    @Test
    public void test3(){
        BiFunction<Integer,String,Employee> func1 = (id, name) -> new Employee(id,name);
        Employee employee = func1.apply(1004, "Tom");
        System.out.println(employee);

        //使用构造器引用
        BiFunction<Integer,String,Employee> func2 = Employee::new;
        Employee employee1 = func2.apply(1005, "jack");
        System.out.println(employee1);
    }

3.3 数组引用

跟构造器引用类似

//数组引用
    //Function 中的 R apply(T t)
    @Test
    public void test4(){

        Function<Integer, String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(8);
        System.out.println(Arrays.toString(arr1));

        //使用数组引用
        Function<Integer, String[]> func2 = String[]::new;
        String[] arr2 = func2.apply(8);
        System.out.println(Arrays.toString(arr2));
        
    }

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值