java函数式接口的使用-自定义函数接口@FunctionalInterface消除if else和内置4大函数式接口

1.自定义函数接口@FunctionalInterface消除if else

@FunctionalInterface
public interface MyFunction<T, R> {
    R apply(T... t);
}

import com.google.common.collect.Maps;

import java.util.Map;

/**
 * 自定义函数消除if else
 */
public class MyFunctionTest {


    //(自定义)一般在静态块中添加
    private static final Map<String, MyFunction<Object, String>> map = createMap();
    //1.初始化函数,代替if else中去执行的函数
    private static Map<String, MyFunction<Object, String>> createMap() {
        Map<String, MyFunction<Object, String>> map = Maps.newHashMap();
        map.put("A", MyFunctionTest::fun01);
        map.put("B", MyFunctionTest::fun02);
        map.put("C", MyFunctionTest::fun03);
        return map;
    }
    public static void main(String[] args) {
        String type = "A";
        // 以前的if-else
//        if(type.equals("A")){
//            fun01("a", 1);
//        }else if(type.equals("B")){
//            fun02("b", 2);
//        }else if(type.equals("C")){
//            fun03("c", 3);
//        }
        // 优化的if-else
        map.get(type).apply("a", 1);
    }

    /**
     * 函数3
     * @param o
     * @return
     */
    private static String fun03(Object... o) {
        System.out.println("fun03=====>");
        for (Object o1 : o) {
            System.out.println(o1);
        }
        return "CCC";
    }
    /**
     * 函数2
     * @param o
     * @return
     */
    private static String fun02(Object... o) {
        System.out.println("fun02=====>");
        for (Object o1 : o) {
            System.out.println(o1);
        }
        return "BBB";
    }
    /**
     * 函数1
     * @param o
     * @return
     */
    private static String fun01(Object... o) {
        System.out.println("fun01=====>");
        for (Object o1 : o) {
            System.out.println(o1);
        }
        return "AAA";
    }

}

2.内置4大函数式接口:

Consumer消费型接口 T void 对类型为T的对象应用操作，包含方法：void accept(T t)
Supplier供给型接口 无 T 返回类型为T的对象，包含方法：T get()
Function<T,R>函数型接口 T R 对类型为T的对象应用操作，并返回结果为R类型的对象。包含方法：R apply(T t)
Predicate断言型接口 T boolean 确定类型为T的对象是否满足某约束，并返回boolean值。包含方法:boolean test(T t)

• 分别给出例子

package org.zz.flink_cdc.if_else;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
* 内置4大函数式接口:
*      Consumer<T>消费型接口	T	void	对类型为T的对象应用操作，包含方法：void accept(T t)
*      Supplier<T>供给型接口	无	T	返回类型为T的对象，包含方法：T get()
*      Function<T,R>函数型接口	T	R	对类型为T的对象应用操作，并返回结果为R类型的对象。包含方法：R apply(T t)
*      Predicate<T>断言型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回boolean值。包含方法:boolean test(T t)
* 分别给出例子
*/
public class Example {
   public static void main(String[] args) {
       //1. 对传入的对象执行某种操作
       // 用于处理或消费数据，执行某些操作但不返回结果。常见于对集合元素的处理，如打印、修改对象属性等
       Consumer<String> printConsumer = s -> {
           System.out.println(s);
       };
       printConsumer.accept("1.Hello, Consumer!");

       //2. 提供一个对象，不接受任何参数
       //用于提供或生成数据，不需要输入参数。常见于延迟计算、对象工厂、获取默认值等场景
       Supplier<String> stringSupplier = () -> "2.Hello, Supplier!";
       System.out.println(stringSupplier.get());

       //3.将输入对象转换为另一种类型的输出
       //用于转换数据，将输入对象转换为另一种类型的输出。常见于数据处理、类型转换、映射操作等场景
       Function<String, Integer> lengthFunction = s -> s.length();
       int length = lengthFunction.apply("3.Hello, Function!");
       System.out.println("Length: " + length);

       //4. 判断输入对象是否满足某个条件
       //用于判断或筛选数据，返回布尔值。常见于条件判断、过滤操作、验证等场景
       Predicate<String> isEmptyPredicate = s -> s.isEmpty();
       boolean isEmpty = isEmptyPredicate.test("");
       System.out.println("4.Is empty: " + isEmpty);
   }
}