JAVA 8 新特性 Lamdba表达式

Java8 新特性：

1、Lamdba表达式
2、函数式接口
3、方法引用和构造引用
4、Stream API
5、接口中的默认方法和静态方法
6、新时间日期API
7、Optional

8、其他特性

Java8 优势：速度快、代码更少（增加了新的语法 Lambda 表达式）、强大的 Stream API、便于并行、最大化减少空指针异常 Optional；

一、Lambda表达式

Lambda 是一个匿名函数，它是一段可以传递的代码（将代码像数据一样进行传递）。可以取代大部分的匿名内部类，可以写出更简洁、更灵活的代码。尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。作为一种更紧凑的代码风格，使 Java 的语言表达能力得到提升。

 JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。 从匿名类到 Lambda 的转换：虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法。

二、为何使用Lambda表达式

1.     提供Functional接口的实现。
2.     编码少

三、Lambda表达式的语法 

   (parameters) -> expression

   或

   (parameters) ->{ statements; }

四、 Lambda表达式重要特征 

1. 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
2. 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
3. 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
4. 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

五、Lambda表达式由三个组件组成

1)参数列表: 也可以为空或非空。

2)箭头令牌: 用于链接参数列表和表达式主体。

3)主体: 它包含表达式和语句

（1）无参数语法

() -> {
//Body of no parameter lambda
}

public class MyLamdba {
    public static void main(String[] args) {
       Person p=()->{
           return "Hello!";
        };
       //输出
        System.out.println(p.say());
    }
}

//@FunctionalInterface   //It is optional
interface Person{
    public String say();
}

 （2）一个参数语法

(a) -> {
//Body of single parameter lambda
}

public class MyLamdba {
    public static void main(String[] args) {
        //一个参数可以使用（）
       Person p=(name)->{
           return "Hello!"+name;
        };
       //输出
        System.out.println(p.say("mike"));

       //一个参数也可以不使用（）
        Person p2=name -> {
            return "Who are you? "+name;
        };

        System.out.println(p2.say("pop"));
    }
}

interface Person{
    public String say(String name);
}

  (3) 两个参数的语法

(p1,p2) -> {
//Body of multiple parameter lambda
}

public class MyLamdba {
    public static void main(String[] args) {
        //多个参数必须使用（）
       Person p=(name,age)->{
           return "Hello!"+name+",Are you "+age+" years old?";
        };
       //输出
        System.out.println(p.say("mike",18));
    }
}

interface Person{
    public String say(String name,int age);
}

（4）返回值带有或不带有return关键字

public class MyLamdba {
    public static void main(String[] args) {
//        one();

        //(1) (parameter)->(expression)
        Addable a1=(a,b)->(a+b);
        System.out.println(a1.add(100,50));

        //(2) (parameter)->{statements}
        Addable a2=(a,b)->{
            return  a+b;
        };
        System.out.println(a2.add(1,5));

    }

}

interface Addable{
    public int add(int a,int b);
}

（5）Foreach循环

 List<String> list= Arrays.asList("sunny","windy","cloudy","rainy");
 list.forEach(m-> System.out.println(m));

六、Lamdba函数接口

    方法引用通过一对双冒号:: 来表示，方法引用是一种函数式接口的另一种书写方式

1. 静态方法引用，通过类名::静态方法名， 如 Integer::parseInt
2. 实例方法引用，通过实例对象::实例方法，如 str::substring 
3. 类名::实例方法名, 如 String::substring
4. 构造方法引用，通过类名::new， 如 User::new

java.util.function 它包含了很多类，用来支持 Java的 函数式编程，该包中的函数式接口有： 

public class MyLamdba2 {
    public static void main(String[] args) {
        //接受一个输入参数 String
        Consumer<String> cc=Pet::show;
        cc.accept("宠物！");

        //接受一个输入参数 Pet
        Consumer<Pet> pet=Pet::eat;
        pet.accept(new Pet());

        //接受两个输入参数 Pet, String
        BiConsumer<Pet,String> p1=Pet::say;
        p1.accept(new Pet(),"你好啊！");

        //接受两个输入参数 Pet, String,并返回一个值Integer
        BiFunction<Pet,String,Integer> p2=Pet::play;
        int num=p2.apply(new Pet(),"好球");
        System.out.println(num);

    }

}

class Pet{
    //静态方法 -有参无返回
    public static void show(String str){
        System.out.println("show方法："+str);
    }

    //实例方法 -无参无返回
    public void eat(){
        System.out.println("eat方法："+this.toString());
    }

    //实例方法 -有参无返回
    public void say(String str){
        System.out.println("say方法："+str);
    }

    //实例方法 -有参有返回
    public int play(String str){
        System.out.println("play方法："+str);
        return 10;
    }
}

用::提取的函数，最主要的区别在于静态与非静态方法，非静态方法比静态方法多一个参数，就是被调用的实例。

 构造方法的引用
   一般我们需要声明接口，该接口作为对象的生成器，通过 类名::new 的方式来实例化对象，然后调用方法返回对象。

public class Student {

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    String name;
    Integer age;

    Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "{" +
                "name=" + name +" " +
                ", age=" + age +
                '}';
    }
}

public class MyLamdba3 {
    public static void main(String[] args) {
        IBlackConstruct ibc = () -> new Student();
        Student stu = ibc.getStudent();
        System.out.println(stu);

        IBlackConstruct ibc2 = Student::new;
        Student stu2 = ibc.getStudent();
        System.out.println(stu2);

        IParameterConstruct ibc3 = Student::new;
        Student stu3 = ibc3.getStudent("zhangsan", 18);
        System.out.println(stu3);

    }
}

interface IBlackConstruct {
    // 对象定义 -无参数
    Student getStudent();
}

interface IParameterConstruct {
    // 对象定义 -有参数
    Student getStudent(String name, int age);
}