函数式接口

函数式接口

有且仅有一个抽象方法的接口，函数式接口是 lambda 表达式的使用前提
可以使用 @FunctionalInterface 进行标记函数式接口
函数式接口作为方法参数时，可以传递过去一个 lambda 表达式

public static void main(String[] args) {
	List<String> array = Arrays.asList("ccc","aa","b","dddd");
    System.out.println("排序前: " + array);

    // Collections.sort(array);// 自然排序
    Collections.sort(array,getComparator());// 比较器排序

    System.out.println("排序后: " + array);
}
private static Comparator<String> getComparator(){
    // 匿名内部类方式
    // return new Comparator<String>() {
    //     @Override
    //     public int compare(String s1, String s2) {
    //         return s1.length() - s2.length();
    //     }
    // };

    // lambda方式, 因为返回值是 函数式接口
    return (s1,s2) -> s1.length() - s2.length();
}

常用的函数式接口

Supplier接口：无中生有

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

Consumer接口：就是消费，无返回值

@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("随便吧",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先执行一次 accept(s)
	// t 再执行一次 accept(s)
}

Predicate接口：判断参数是否满足指定条件

boolean test(T t)// 对给定参数进行判断, 判断逻辑由 lambda 提供
public static void main(String[] args) {
	boolean res = checkString("fewef", s -> s.length() > 8);
}
private static boolean checkString(String s, Predicate<String> t){
	// return t.test(s);
	// return t.negate().test(s);						// 非
	// return t.and(a -> a.startsWith("fy")).test(s);	// 与
	return t.or(a -> a.startsWith("fy")).test(s);		// 或
}

Function接口：对参数进行处理，转换，返回一个新的值。

@FunctionalInterface
public interface Function<T, R> {		// T 是函数输入的类型
    R apply(T t);						// R 是函数结果的类型
    // 对输入 进行两次 逻辑处理
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        return (T t) -> after.apply(apply(t));
    }
}

类方法和实例方法