自定义函数式接口

需求：实现两数的加减乘除

接口，函数式接口只能有一个抽象方法，且需要用注释@FunctionInterface。

@FunctionalInterface
public interface calculate {
    int operator(int t1, int t2);
}

在operator中将函数式接口作为参数传递，然后在输出中使用lambada表达式。

public class Main {
    public static int operator(int a, int b, calculate c) {
        return c.operator(a,b);
    }
    public static void main(String[] args) {
        System.out.println(operator(1,1,(x,y)->x+y));
        System.out.println(operator(1,1,(x,y)->x-y));
        System.out.println(operator(1,1,(x,y)->x*y));
        System.out.println(operator(1,1,(x,y)->x/y));
    }
}

lambada表达式实际上就是一种动作，上述需求中就是要求出两数的算数结果。

(x,y)->x+y

但想用lambada表达式就得声明函数式接口

@FunctionalInterface

动作的结果即算数结果是在方法operator中返回的，返回的结果在println中进行输出。

int operator(int a, int b, calculate c)

常用的内置函数式接口

1.Supplier接口

T get();

用来获取结果

求数组的最大值

public class Main {
    public static int getMax(Supplier<Integer> s) {
        return s.get();
    }
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5,6,7,8,9,10};
        int max = getMax(()->{
            int m = arr[0];
            for(int i:arr) {
                if(i>m) m = i;
            }
            return m;
        });
        System.out.println(max);
    }
}

2.Consumer接口

抽象方法：void accept(T t)

默认方法： addThen()

格式化打印

public class Main {
    public static void printInfo(Consumer<String> a,Consumer<String> b, String[] arr) {
        for(String s:arr)
            a.andThen(b).accept(s);
    }
    public static void main(String[] args) {
        String[] arr = {"绘画，素描","舞蹈，震撼舞"};
        printInfo(s-> System.out.print(s.split("，")[0]),
                s-> System.out.println(":"+s.split("，")[1]),
                arr);
    }
}

3.Predicate接口

抽象方法：void test()

默认方法：and(与）、or(或）、negate(或）

判断字符串中是否含有a和b

public class Main {
    public static void judge(Predicate<String> a, Predicate<String> b) {
        System.out.println(a.and(b).test("abc"));
    }
    public static void main(String[] args) {
        judge(s->s.contains("a"),s->s.contains("b"));
    }
}

4.Function接口

抽象方法：R apply(T t)

默认方法：andThen

将String转化为apply

public class Main {
    public static void trans(Function<String,Integer> f) {
        System.out.println(f.apply("10"));;
    }
    public static void main(String[] args) {
        trans(s->Integer.parseInt(s));
    }
}