[JDK1.8新特性]--Lambda表达式

一、JDK1.8 新特性


JDK1.8概述:


JDK1.8,又称之为Java 8(我习惯叫它为JDK1.8,后续统一叫做JDK1.8),是Java语言开发的一个主要版本。Oracle公司于2014年3月18日发布,它支持函数式编程,新的JavaScript引擎,新的日期API,新的Stream API等。

JDK1.8相比1.7之前版本,有以下几方面的优化:

  • Lambda表达式
  • 函数式接口
  • 方法引用和构造器调用
  • Stream API
  • 接口中的默认方法和静态方法
  • 新时间日期API

二、Lambda表达式

Lambda表达式本质上是一段匿名内部类,也可以是一段可以传递的代码

1.Lambda 表达式与传统方式的区别

使用匿名内部类存在的问题 当需要启动一个线程去完成任务时,通常会通过 Runnable 接口来定义任务内容,并使用 Thread 类来启动该线程。

传统写法

  代码如下:

package com.zhq.test;
 
public class Lambda01 {
    public static void main(String[] args) {
         /*
         一、使用匿名内部类存在的问题
         public Thread(Runnable target)
         二、匿名内部类做了哪些事情
         1.定义了一个没有名字的类
         2.这个类实现了Runnable接口
         3.创建了这个类的对象
         以上可以看出:
            1.使用匿名内部类语法是很冗余的
            2.其实我们最关注的是run方法和里面要执行的代码.
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类方式");
            }
        }).start();
    }
}

 

由于面向对象的语法要求,首先创建一个 Runnable 接口的匿名内部类对象来指定线程要执行的任务内容,再将其交 给一个线程来启动。

 代码分析:

  • 对于 Runnable 的匿名内部类用法,可以分析出几点内容: T
  • hread 类需要 Runnable 接口作为参数,其中的抽象 run 方法是用来指定线程任务内容的核心
  • 为了指定 run 的方法体,不得不需要 Runnable 接口的实现类
  • 为了省去定义一个 Runnable 实现类的麻烦,不得不使用匿名内部类
  • 必须覆盖重写抽象 run 方法,所以方法名称、方法参数、方法返回值不得不再写一遍,且不能写错
  • 而实际上,似乎只有方法体才是关键所在。

 Lambda表达式写法

  代码如下:

package com.zhq.test;
 
public class Lambda01 {
    public static void main(String[] args) {
 
        //Lambda表达式
        //Lambda表达式体现的是函数式编程思想,只需要将要执行的代码放到函数中(函数就是类中的方法)
        //Lambda就是一个匿名函数, 我们只需要将要执行的代码放到Lambda表达式中即可
        new Thread(() -> {
            System.out.println("Lambda表达式");
        }).start();
        
    }
}

 Lambda的优点:

 从以上案例中可以看出Lambda表达式简化匿名内部类的使用,语法更加简单。

 小结:

了解了匿名内部类语法冗余,体验了Lambda表达式的使用,发现Lmabda是简化匿名内部类的简写 

2.Lambda的标准格式

Lambda省去面向对象的条条框框,Lambda的标准格式格式由3个部分组成:

(参数类型 参数名称) -> {

        代码体;

}

 

格式说明:

  • (参数类型 参数名称):参数列表
  • {代码体;}:方法体
  • -> :箭头,分隔参数列表和方法体

 无参无返回值的Lambda

先定义一个学生接口:

package com.zhq.test;
 
public interface Student {
    public abstract void Student();
}
package com.zhq.test;
 
public class Lambda02 {
    public static void main(String[] args) {
        //匿名内部类
        goStudent(new Student() {
            @Override
            public void Student() {
                System.out.println("我是匿名内部类的学生");
            }
        });
        //Lambda表达式
        goStudent(() -> {
            System.out.println("我是Lambda的学生");
        });
    }
    public static void goStudent(Student s) {
        s.Student();
    }
}

 

有参有返回值的Lambda

下面举例演示java.util.Comparator接口的使用场景代码,其中的抽象方法定义为:

public abstract int compare(T o1, T o2);

当需要对一个对象集合进行排序时,Collections.sort方法需要一个Comparator接口实例来指定排序的规则。

先定义一个学生实体类:

package com.zhq.test;
 
public class Students {
    private String name;
    private int score;
    private int age;
 
    //给上getset,toString,有参无参构造
}

 传统写法: 

 

 public static void main(String[] args) {
        ArrayList stus=new ArrayList<>();
        stus.add(new Students("李四",80,23));
        stus.add(new Students("张三",90,22));
        stus.add(new Students("王五",70,24));
 
        Collections.sort(stus, new Comparator() {
            @Override
            public int compare(Students o1, Students o2) {
                return o1.getAge()-o2.getAge();
            }
        });
 
        for(Students students : stus) {
            System.out.println(students);
        }
 
    }

Lambda表达式:

    public static void main(String[] args) {
        ArrayList stus=new ArrayList<>();
        stus.add(new Students("李四",80,23));
        stus.add(new Students("张三",90,22));
        stus.add(new Students("王五",70,24));
 
        Collections.sort(stus,(o1,o2) ->{ return -(o1.getAge()-o2.getAge()); } );
 
        for(Students students : stus) {
            System.out.println(students);
        }
 
    }

 小结:

以后我们调用方法时,看到参数是接口就可以考虑使用Lambda表达式,Lambda表达式相当于是对接口中抽象方法的重写

3.Lambda省略格式

在Lambda标准格式的基础上,使用省略写法的规则为:

  • 1. 小括号内参数的类型可以省略
  • 2. 如果小括号内有且仅有一个参数,则小括号可以省略
  • 3. 如果大括号内有且仅有一个语句,可以同时省略大括号、return关键字及语句分号
//省略前:
(int a) -> { 
 return new Student(); 
} 

//省略后:
a -> new Student()

4.Lambda的前提条件

Lambda的语法非常简洁,但是Lambda表达式不是随便使用的,使用时有几个条件要特别注意:

  • 1. 方法的参数或局部变量类型必须为接口才能使用Lambda
  • 2. 接口中有且仅有一个抽象方法

案例: 

 设一个接口,给上一个抽象方法

public interface Flyable { 
    public abstract void flying(); 
} 
public static void main(String[] args) { 
        test01(() -> { 
        }); 
 
        Flyable s = new Flyable() { 
            @Override 
            public void flying() { 
            } 
        }; 
 
        Flyable s2 = () -> { 
        }; 
    } 
 
    public static void test01(Flyable fly) { 
        fly.flying(); 
    } 

 

5.Lambda和匿名内部类对比


1. 所需的类型不一样

  • 匿名内部类,需要的类型可以是类,抽象类,接口
  • Lambda表达式,需要的类型必须是接口

2. 抽象方法的数量不一样

  • 匿名内部类所需的接口中抽象方法的数量随意
  • Lambda表达式所需的接口只能有一个抽象方法

3. 实现原理不同

  • 匿名内部类是在编译后会形成class
  • Lambda表达式是在程序运行的时候动态生成class

三、函数式接口

函数式接口在Java中是指:有且仅有一个抽象方法的接口。

函数式接口,即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda,所以函数式接口就是可以 适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导。

FunctionalInterface注解

与 @Override 注解的作用类似,Java 8中专门为函数式接口引入了一个新的注解: @FunctionalInterface 。

该注解可用于一个接口的定义上: 

@FunctionalInterface
public interface Operator {
    void myMethod();
}

 作用:

一旦使用该注解来定义接口,编译器将会强制检查该接口是否确实有且仅有一个抽象方法,否则将会报错。不过,即 使不使用该注解,只要满足函数式接口的定义,这仍然是一个函数式接口,使用起来都一样。



原文链接:https://blog.csdn.net/weixin_57504000/article/details/124558903

你可能感兴趣的:(服务端-JavaSE,javascript,java,开发语言)