1.函数式接口

函数式接口（Functional Interface）就是一个有且仅有一个抽象方法（通俗来说就是只有一个方法要去被实现，因此我们也能通过这个去动态推断参数类型），但是可以拥有多个非抽象方法的接口。函数式接口可以被隐式转换为lambda表达式。通常被用在Lambda表达式和方法引用上。

 2.Lambda表达式与"::"方法引用

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。计算时，方法引用会创建函数式接口的一个实例。

当Lambda表达式中只是执行一个方法调用时，不用Lambda表达式，直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的Lambda表达式

 举例：

 

package com.yukuanyan.entity;

public class Person {
    private String name;

    private Integer age;

    public Person() {}

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

    public static int compare(Person a,Person b) {
        int r = a.getAge().compareTo(b.getAge());
        if (r != 0) {
            return r;
        } else {
            return a.getName().compareTo(b.getName());
        }
    }

    public static int compare(Person a,Person b,Person c) {
        return 0;
    }

    public Person concat(Person b) {
        this.setName(this.getName() + "," + b.getName());
        System.out.println(this);
        return this;
    }

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

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

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

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }
}

case1：

package com.yukuanyan.cases;

import com.yukuanyan.entity.Person;

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

public class case1 {

    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("zhangsan",33),new Person("lisi",22),new Person("wangwu",11));

        // 传统写法
        personList.sort(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });

        // Lambda 写法
        personList.sort((a,b) -> Person.compare(a,b));

        // 方法引用写法，调用static方法，参数类型动态推断
        personList.sort(Person::compare);

        System.out.println(personList);
    }
}

 

 case2：正式工作中用的比较多的stream流应用

package com.yukuanyan.cases;

import com.yukuanyan.entity.Person;

import java.util.Arrays;
import java.util.List;

public class case2 {
    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("zhangsan",33),new Person("lisi",22),new Person("wangwu",11));

        personList.stream().sorted(Person::compare).forEach(System.out::println);
    }
}

case3：调用对象方法

package com.yukuanyan.cases;

import com.yukuanyan.entity.Person;

import java.util.Arrays;
import java.util.List;

public class case3 {
    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("zhangsan",33),new Person("lisi",22),new Person("wangwu",11));
        Person p = new Person("zhaoliu",44);
        personList.stream().sorted(Person::compare).forEach(p::concat);

    }
}

case4："::new"实例化对象

package com.yukuanyan.cases;

import com.yukuanyan.entity.Person;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class case4 {
    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("zhangsan",33),new Person("lisi",22),new Person("wangwu",11));
        Person p = new Person("zhaoliu",44);
        personList.stream().sorted(Person::compare).collect(Collectors.toCollection(ArrayList::new));

    }
}