JDK1.8 新特性

一、功能接口

Java 8 引入了@FunctionalInterface，一個只有一個抽象方法的接口。編譯器會將任何滿足函數式接口定義的接口視為函數式接口；
這意味着@FunctionalInterface注釋是可選的。

讓我們看看六個基本的功能接口。

接口	簽名	示例
UnaryOperator	T apply(T t)	String::toLowerCase, Math::tan
BinaryOperator	T apply(T t1, T t2)	BigInteger::add, Math::pow
Function<T, R>	R apply(T t)	Arrays::asList, Integer::toBinaryString
Predicate<T, U>	boolean test(T t, U u)	String::isEmpty, Character::isDigit
Supplier	T get()	LocalDate::now, Instant::now
Consumer	void accept(T t)	System.out::println, Error::printStackTrace

二、 Lambda 表達式和方法參考

Java 8 引入了 lambda 表達式來提供函數接口的抽象方法的實現。

public interface Iterable {
//...

default void forEach(Consumer<? super T> var1) {
    Objects.requireNonNull(var1);
    Iterator var2 = this.iterator();

    while(var2.hasNext()) {
        Object var3 = var2.next();
        var1.accept(var3);
    }

}

//......
}

使用Collections.sort示例

新建一個Student類，然后根據id進行排序

@Data
public class Student {

    private Integer id;
    private String name;
    private String age;

使用Collections.sort進行排序

    public List<Student> getStudents(){
        List<Student> result = new ArrayList<>();
        result.add(new Student(1,"小易","21"));
        result.add(new Student(2,"小二","23"));
        result.add(new Student(4,"小思","24"));
        result.add(new Student(3,"小三","24"));
        return result;
    }

    @Test
    public void ComparatorTest(){
        List<Student> listStudent = getStudents();
        for (Student student : listStudent) {
            System.out.println("使用for循環遍歷出來"+student);
        }

        System.out.println("========================");

        Collections.sort(listStudent, new Comparator<Student>() {
            @Override
            public int compare(Student t1, Student t2) {
                return t1.getId() - t2.getId();
            }
        });

        System.out.println(listStudent);

    }

使用Lambda 簡化Collections.sort開發

List接口sort直接支持該方法，不再需要使用Collections.sort

    @Test
    public void LambdaComparatorTest(){
        List<Student> listStudent = getStudents();
        for (Student student : listStudent) {
            System.out.println("使用for循環遍歷出來"+student);
        }
        System.out.println("========================");

        listStudent.sort(new Comparator<Student>() {
            @Override
            public int compare(Student t1, Student t2) {
                return t1.getId() - t2.getId();
            }
        });
        System.out.println(listStudent);
    }

使用Lambda打印

    @Test
    public void LambdaComparatorTest(){
        System.out.println("===========  for循環遍歷  =============");
        List<Student> listStudent = getStudents();
        for (Student student : listStudent) {
            System.out.println("使用for循環遍歷出來"+student);
        }
        System.out.println("===========  lambda  =============");

        //lambda
        listStudent.sort((Student t1,Student t2)->t1.getId() - t2.getId());
        System.out.println(listStudent);
        
        System.out.println("===========  在forEach使用lambda 打印  =============");
        
        //lambda也支持print打印
        listStudent.forEach((student -> {System.out.println(student);}));
        //為了更好的可讀性 使用方法引用
        listStudent.forEach(System.out::println);           // method references

    }

這一段可以更簡化：listStudent.sort((Student t1,Student t2)->t1.getId() - t2.getId());
如下：簡化了很多，但是缺點別人接手你的代碼 如果很多代碼使用lambda有一定難度消化（我以前就是）
listStudent.sort((t1,t2)->t1.getId() - t2.getId());

按名稱排序

        listStudent.sort((Student t1,Student t2)->t1.getName().compareTo(t2.getName()));

查看sort的源碼

會走這個方法

    private static <T> void binarySort(T[] var0, int var1, int var2, int var3, Comparator<? super T> var4) {
        assert var1 <= var3 && var3 <= var2;

        if (var3 == var1) {
            ++var3;
        }

        while(var3 < var2) {
            Object var5 = var0[var3];
            int var6 = var1;
            int var7 = var3;

            assert var1 <= var3;

            int var8;
            while(var6 < var7) {
                var8 = var6 + var7 >>> 1;
                if (var4.compare(var5, var0[var8]) < 0) {
                    var7 = var8;
                } else {
                    var6 = var8 + 1;
                }
            }

            assert var6 == var7;

            var8 = var3 - var6;
            switch(var8) {
            case 2:
                var0[var6 + 2] = var0[var6 + 1];
            case 1:
                var0[var6 + 1] = var0[var6];
                break;
            default:
                System.arraycopy(var0, var6, var0, var6 + 1, var8);
            }

            var0[var6] = var5;
            ++var3;
        }

    }

主要代碼
int var8;
while(var6 < var7) {
var8 = var6 + var7 >>> 1;
if (var4.compare(var5, var0[var8]) < 0) {
var7 = var8;
} else {
var6 = var8 + 1;
}
}