Functional interface

Functional interface

Interface with and only one abstract method , A functional interface is lambda The premise of expression .
have access to @FunctionalInterface marked Functional interface .
Using functional interfaces As a method parameter , You can pass on the past lambda expression .

public class lambdademo {
    
    public static void main(String[] args) {
    

        ArrayList<String> array = new ArrayList<>();
        array.add("ccc");
        array.add("aa");
        array.add("b");
        array.add("dddd");
        System.out.println(" Before ordering : " + array);

// Collections.sort(array); //  Natural ordering 
        Collections.sort(array,getComparator());    //  Comparator sort 

        System.out.println(" After ordering : " + array);

    }

    private static Comparator<String> getComparator(){
    

//  Anonymous inner class mode 
// return new Comparator<String>() {
    
// @Override
// public int compare(String s1, String s2) {
    
// return s1.length() - s2.length();
// }
// };

// lambda The way ,  Because the return value is   Functional interface 
        return (s1,s2) -> s1.length() - s2.length();

    }
}

Common functional interfaces

Functional interface , When making parameters of the method , When calling, it actually passes a lambda The expression is OK .
Supplier Interface

@FunctionalInterface
public interface Supplier<T> {
    
    T get();
}

Consumer Interface

@FunctionalInterface
public interface Consumer<T> {
    
    void accept(T t);
    
    default Consumer<T> andThen(Consumer<? super T> after) {
    
        return (T t) -> {
     accept(t); after.accept(t); };
    }
}

getString(" Xy: ",System.out::print);
private static void getString(String s, Consumer<String> cn){
    
// cn.accept(s);
	Consumer<String> t = a -> System.out.print(a.length() + 1);
	cn.andThen(t).accept(s);
// cn Do it first  accept(s)
// t  Execute it again  accept(s)
}

Predicate Interface
It is often used to judge whether parameters meet specified conditions

boolean test(T t)			//  Judge the given parameters ,  The logic of judgment consists of  lambda  Provide 
default Predicate<T> negate()
default Predicate<T> and(Predicate other)
default Predicate<T> or(Predicate other)

    public static void main(String[] args) {
    

        boolean res = checkString("fewef", s -> s.length() > 8);
        System.out.print(res);

    }

    private static boolean checkString(String s, Predicate<String> t){
    
// return t.test(s);
// return t.negate().test(s); //  Not 
// return t.and(a -> a.startsWith("fy")).test(s); //  And 
        return t.or(a -> a.startsWith("fy")).test(s);		//  or 
    }

Function Interface
Function Interface is used to process parameters , transformation , Returns a new value .

@FunctionalInterface
public interface Function<T, R> {
    		// T  Is the type of function input 
    R apply(T t);						// R  Is the type of function result 
    
    //  For input   Do it twice   Logical processing 
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    
        return (T t) -> after.apply(apply(t));
    }
}

Class methods and instance methods