java 8 新特性 笔记

一.Lambda的定义

Lambda表达式有参数、箭头和主体组成。
左侧：指定了Lambda表达式需要的所有参数 ；右侧：指定了Lambda体，即lambda表达式要执行的功能
 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
 Lambda有参数列表、函数主体、返回类型，还可能有可以抛出的异常列表。
lambda表达式本质上是一个匿名类。lambda表达式也常被称为闭包。
格式如下:
(parameters) -> expression或(parameters) ->{statements; }
// 1. 不需要参数,返回值为 5  
() -> 5  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)  

例子：

package com.ljf.java8.demo.lamda;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @className SortTest
 * @Description TODO
 * @Author admin
 * @Date 2019/5/16 18:34
 * @Version 1.0
 **/


public class SortTest {
    public static void main(String args[]){
    System.out.println("");
        List<String> List = Arrays.asList("peter", "anna", "mike", "xenia");
         //匿名类的方式
        Collections.sort(List, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a);
            }
        });
        System.out.println(""+List.toString());
        //lambda表达式的写法
        Collections.sort(List, (String a, String b) -> {
            return b.compareTo(a);
        });
        System.out.println(""+List.toString());
        //lambda表达式的简写
        Collections.sort(List, (String a, String b) -> b.compareTo(a));
        System.out.println(""+List.toString());
    }
    //https://blog.csdn.net/zhwyj1019/article/details/80585245
    //https://blog.csdn.net/Alex_cun/article/details/80191327
   // https://blog.csdn.net/zhwyj1019/article/details/80585245
   // http://blog.didispace.com/books/java8-tutorial/ch1.html
}

结果为：
[xenia, peter, mike, anna]
[xenia, peter, mike, anna]
[xenia, peter, mike, anna]

二.函数式接口的定义

一个所谓的函数式接口必须要有且仅有一个抽象方法的声明。（接口中的方法都为public abstract）
每一个lambda都能够通过一个特定的接口，与一个给定的类型进行匹配。使用lambda表达式，一般需要先定义函数接口

例子：

public interface QiuHe {
    public abstract int  calculate(int x,int y);
}


public class QiuHeImpl implements QiuHe{
    @Override
    public int calculate(int x, int y) {
        return x+y;
    }
}

public class TestQiuhe {
    public static void main(String args[]){
        //1.一般方式：通过子类对象调用
        QiuHe qiuHeImpl=new QiuHeImpl();
       int m= qiuHeImpl.calculate(3,4);
       System.out.println("子类对象调用:"+m);
       //2.通过匿名类的调用
        QiuHe qiuHe2=new QiuHe() {
            @Override
            public int calculate(int x, int y) {
                return x+y;
            }
        };
      int t=  qiuHe2.calculate(3,4);
        System.out.println("匿名类的调用:"+t);
       // 3.  通过函数接口（含lambda表达式）
       QiuHe qiuHe=(int a,int b)-> { return a+b;};
      int s=qiuHe.calculate(3,4);
      System.out.println("通过函数接口:"+s);

    }
}

三.lambda调用方法

Java 8 允许你通过::关键字获取方法或者构造函数的的引用

其实，方法引用就是Lambda表达式，就是函数式接口的一个实例，可以认为是Lambda表达式的一个语法糖。但是，并不是所有的Lambda表达式都可以使用方法引用来表示，需要满足一定的条件(抽象接口的实现需满足一定的条件)，才能使用方法引用表示。

我们可以把方法引用理解为方法的指针，指向的是另外一个方法。也就是说，如果抽象方法的实现恰好可以使用调用另外一个方法来实现，就有可能可以使用方法引用。注意是有可能。下面就对方法引用来进行介绍。

方法引用总共分为4类：

1. 类名::静态方法名
2. 对象名::实例方法名
3. 类名::实例方法名
4. 构造方法引用： 类名::new

例子：

package com.ljf.java8.demo.FunctionInterfaceDm;

/**
 * @className Student
 * @Description TODO
 * @Author admin
 * @Date 2019/5/17 15:05
 * @Version 1.0
 **/


public class Student {
    private String address;

    private String name="123";

    private Integer age;
    public int compareByName(Student student) {
        return this.getName()
                .compareToIgnoreCase(student.getName());
    }
  public  void show(){
    System.out.println("我是一个非静态方法");
}
    /**
     *
     */
   public static void say(Student stu){
       System.out.println("我是一个静态方法："+stu.name);

   }
    public Student() {
    }

    public Student(String address) {
        this.address = address;
    }

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

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    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;
    }
}



package com.ljf.java8.demo.FunctionInterfaceDm;

import java.util.function.*;

/**
 * @className TestStudent
 * @Description TODO
 * @Author admin
 * @Date 2019/5/17 15:08
 * @Version 1.0
 **/


public class TestStudent {
    public static void main(String args[]){
    System.out.println("");
        Student emp = new Student("上海", "xiaoMIng", 18);
        //第一种  一般表达式
        Supplier<String> supper1 = () -> emp.getAddress();
        System.out.println(supper1.get());//上海
        //第二种 对象实例::实例方法名
        Supplier<String> supper = emp::getAddress;
        System.out.println(supper.get()); //上海
        //第三种   类:: 静态方法
        Consumer<Student> consumer2 =Student::say;//我是一个静态方法xiaoMIng
        consumer2.accept(emp); //
        //第四种   类:: 实例方法名
        Consumer<Student> consumer1  = Student::show;//我是一个非静态方法
         consumer1.accept(emp);
        /*************** 构造器的引用 ****************/
        // 无参构造函数，创建实例
        Supplier<Student> supper2 = () -> new Student();
        Supplier<Student> supper3 = Student::new;
        Student emp1 = supper3.get();
        emp1.setAddress("北京");
        Supplier<String> supp = emp1::getAddress;
        System.out.println(supp.get());   //北京
        // 一个参数
        Function<String, Student> fun = address -> new Student(address);
        Function<String, Student> fun1 = Student::new;
        System.out.println(fun1.apply("beijing").getAddress());//beijing

        // 两个参数
        BiFunction<String, Integer, Student> bFun = (name, age) -> new Student(name, age);
        BiFunction<String, Integer, Student> bFun1 = Student::new;
        System.out.println(bFun1.apply("xiaohong", 18).getName());//xiaohong

       // https://blog.csdn.net/qq_28410283/article/details/80963351
    }
}

 //https://my.oschina.net/aronykl/blog/1507084