public static <T>
    Collector<T, ?, List<T>> toList() {
        return new CollectorImpl<>(ArrayList::new, List::add,
                                   (left, right) -> { left.addAll(right); return left; },
                                   CH_ID);
    }

CollectorImpl(Supplier<A> supplier,
                      BiConsumer<A, T> accumulator,
                      BinaryOperator<A> combiner,
                      Set<Characteristics> characteristics) {
            this(supplier, accumulator, combiner, castingIdentity(), characteristics);
        }

void accept(T t, U u);

boolean add(E e)
void add(int index, E element);

package study.base.oop.interfaces.functional.stdimplement.impl;

import study.base.oop.interfaces.functional.stdimplement.Face;
import study.base.oop.interfaces.functional.stdimplement.IFace;
import study.base.oop.interfaces.functional.stdimplement.Isort;
import study.base.oop.interfaces.functional.stdimplement.Sort;

/**
 * 本类主要演示了函数式接口的几种实现方式:
 * </br>
 * </br> 1.使用实现类  - 最传统的
 * </br> 2.使用Lambda表达式 - 还是比较方便的
 * </br> 3.使用匿名类 - 和郎打差不多
 * </br> 4.方法引用 -   应用另外一个同形方法（多式对实例）
 * </br> 5.构造器引用 -  应用另外一个同形构造方法
 * </br> 6.静态方法引用 -  应用另外一个同形静态方法
 * @author lzf
 */
public class StudentSortImpl implements Isort {

    @Override
    public int add(int a, int b) {
        int total = a + b;
        System.out.println(total);
        this.doSomething(a,b);
        return total;
    }

    public static void main(String[] args) {
        // 1.0 函数式接口的传统实现-类实现
        System.out.println("1.函数式接口的实现方式一:实现类");
        Isort sort = new StudentSortImpl();
        sort.add(10, 20);

        // 函数式接口的实现二-朗打方式
        System.out.println("2.函数式接口的实现方式一:朗打表达式");
        // 2.1 有返回的情况下，注意不要return语句,只能用于单个语句的
        // 如果只有一个参数，可以省掉->前的小括弧
        // 如果有返回值，某种情况下，也可以省略掉后面的花括弧{}
        // 有 return的时候
        // a->a*10
        // (a)->{return a*10} 要花括弧就需要加return
        // (a,b)->a+b
        // (a,b)->{return a+b;}
        Isort sort2 = (a, b) -> a + b;
        Isort sort3 = (a, b) -> {
            return a * 10 + b;
        };

        // 2.2 有没有多条语句都可以使用 ->{}的方式
        Isort sort4 = (a, b) -> {
            a += 10;
            return a + b;
        };
        
        int a=10;
        int b=45;
        int total=sort2.add(a, b)+sort3.add(a, b)+sort4.add(a, b);
        System.out.println("总数="+total);

        // 3 使用 new+匿名函数的方式来实现
        System.out.println("3.函数式接口的实现方式一:匿名类");
        Isort sort5 = new Isort() {
            @Override
            public int add(int a, int b) {
                int total = a * a + b;
                System.out.println(total);
                return total;
            }

        };
        sort5.add(8, 2);

        // 4.0 基于方法引用-利用已有的方法，该方法必须结构同接口的方式一致
        // 在下例中，从另外一个类实例中应用，而该实例仅仅是实现了方法，但是没有实现接口
        // 可以推测：编译的时候，通过反射或者某些方式实现的。具体要看编译后的字节码
        System.out.println("4.函数式接口的实现方式一:方法引用");
        Sort otherClassSort=new Sort();
        Isort methodSort = otherClassSort::add;
        methodSort.add(90, 90);
        
        // 5.0 基于构造函数
        // 这种方式下，要求构造函数返回的对象类型同函数接口的返回一致即可，当然参数也要一致
        System.out.println("5.函数式接口的实现方式一:构造函数引用");
        IFace conSort=Face::new;
        
        Face face=conSort.show(10, 90);
        face.write();
        //小结：基于方法和基于构造函数的实现，应该仅仅是为了stream和函数式服务，和朗打没有什么关系
        //这个最主要是为了编写一个看起来简介的表达式。
        // 6.0 基于静态方法
        System.out.println("6.函数式接口的实现方式一:静态方法引用");
        Isort staticSort=Integer::sum;
        int total2=staticSort.add(1,2);
        System.out.println("total2="+total2);
    }
}