JAVA Foundation 5-Functional Interface Implementation

 public static <T>
    Collector<T, ?, List<T>> toList() {
        return new CollectorImpl<>(ArrayList::new, List::add,
                                   (left, right) -> { (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 ;

import ;
import ;
import ;
import ;

/**
 * This class demonstrates several implementations of the functional interface:.
 * </br>
 * </br> 1. Using an implementation class - the most traditional.
 * </br> 2. Use Lambda expressions - still more convenient!
 * </br> 3. Use anonymous classes - pretty much the same as Lang.
 * </br> 4. Method references - applying another homomorphic method (polytope to instance)
 * </br> 5. Constructor references - applying another isomorphic constructor method.
 * </br> 6. Static method references - apply another isomorphic static method.
 Static method references - apply another isomorphic static method * </br>@author lzf
 */
public class StudentSortImpl implements Isort {

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

    public static void main(String[] args) {
        // 1.0 Traditional Implementation of Functional Interfaces - Class Implementation
        ("1. Functional Interface Implementation I: Implementing Classes");
        Isort sort = new StudentSortImpl();
        (10, 20);

        // Implementation of Functional Interfaces II - The Langham Approach
        ("2. Functional Interfaces Implementation I: Lambda Expressions");
        // 2.1 In the case of a return, be careful not to return statements, which can only be used in a single statement.
// If there is only one argument, you can omit the parentheses before the ->.
// If there is a return value, in some cases it is also possible to omit the trailing curly braces {}
// When there is a return
// a->a*10
        // (a)->{return a*10} You need to add return if you want to spend brackets.
// (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 Is there more than one statement that can be used ->{}
        Isort sort4 = (a, b) -> {
            a += 10;
            return a + b;
        };
        
        int a=10;
        int b=45;
        int total=(a, b)+(a, b)+(a, b);
        ("aggregate="+total);

        // 3 Use new+anonymous functions to implement the
        ("3. Implementation of Functional Interfaces I: Anonymous Classes");
        Isort sort5 = new Isort() {
            @Override
            public int add(int a, int b) {
                int total = a * a + b;
                (total);
                return total;
            }

        };
        (8, 2);

        // 4.0 Based on method references-utilizes existing methods, which must be structured in a way that is consistent with the interface
// In the following example, applying from another class instance that simply implements the methods but not the interface
// It can be speculated that: when compiled, it is implemented by reflection or some way. It depends on the compiled bytecode
        ("4. Functional Interface Implementation I: Method References");
        Sort otherClassSort=new Sort();
        Isort methodSort = otherClassSort::add;
        (90, 90);
        
        // 5.0 Constructor-based
// In this way, the type of the object returned by the constructor should be the same as that returned by the function interface, and of course the parameters should be the same.
        ("5. Implementation of Functional Interfaces I: Constructor References");
        IFace conSort=Face::new;
        
        Face face=(10, 90);
        ();
        //Summary: method-based and constructor-based implementations should be for stream and functional services only, and have little to do with rumination
//This one is most definitely for writing a synopsis-looking expression.
// 6.0 Based on static methods
        ("6. Functional Interface Implementation I: Static Method References");
        Isort staticSort=Integer::sum;
        int total2=(1,2);
        ("total2="+total2);
    }
}