JDK1.8新特性之Lambda表达式_jdk 1.8 表达式

一、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<T>接口的使用场景代码，其中的抽象方法定义为：

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<Students> 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<Students>() {
            @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<Students> 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();
}

作用

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

 博主水平有限，难免有错。欢迎评论交流