Java 函数式接口实战 java函数式接口实际使用

java中函数式接口的使用

一、自己创建的函数式接口

1.1 概念

只存在一个抽象方法的接口。

1.2 使用步骤：

1、创建函数式接口，创建格式参照使用格式。
2、创建一个实例类
3、在实例类中使用函数式接口。

1.3 使用格式：

创建函数式接口的格式：
@FunctionalInterface // 注解，用于检测接口是否为函数式接口，是编译成功、否编译失败
public Interface 接口名称{
public abstract 数据类型(例如：void int boolean) 方法名称();
其他非抽象方法，即默认、静态、私有方法(可以省略)
}

1.4 示例：

@FunctionalInterface
    public interface MyFunctionInterface {
        public abstract void method();
    }

1.5 注意事项：

1、只有一个抽象方法的接口才能称为函数式接口。
2、函数式接口中能存在非抽象方法(即默认、静态、私有方法)，非抽象方法根据自己的需要进行编写。
3、函数式接口中实例类中一般作为方法的参数或者返回值使用，或者创建一个接口实现类然后在实例类中调用实现类使用。

二、Supplier接口

2.1 功能

返回泛型参数指定数据类型数据的接口，用于生产数据。

2.2 作为方法参数时的使用步骤

1、在类中创建一个方法，参数为Supplier接口。
2、在主方法中调用该方法，可以传递Supplier接口实现类、Supplier接口加重写方法、Lambda表达式的方式写实现方法。

2.3 注意事项

1、Supplier接口无参数，有返回值
2、Supplier接口返回数据的数据类型根据泛型传递的数据类型决定。

2.4 使用格式

2.4.1、创建方法，参数为Supplier接口
public static 数据类型 方法名(Supplier<数据类型> 参数名){
return 参数名.get();
}
2.4.2、调用方法
使用Supplier接口实现类：
数据类型 变量名 = 方法名称(new Supplier接口实现类);
使用匿名内部类：
数据类型 变量名 = 方法名称(new Supplier<数据类型>(){
@Override
public 数据类型 get(){
处理代码
return 指定数据类型的数据
}
});
使用Lambda表达式:
数据类型 变量名 = 方法名称(()->{
处理代码
return 指定数据类型的数据
});

2.5 示例

使用匿名内部类：
String s3 = getSupplier(new Supplier<String>() {
            @Override
            public String get() {
                return "可莉";
            }
        });

Lambda表达式：
String s1 = getSupplier(()->{
            return 1+"";
        });

三、Consumer接口

3.1 功能

用于对传递进来的数据进行处理的接口，用于消费数据。

3.2 作为方法参数时的使用步骤

1、创建一个方法，参数为需要处理的数据和Consumer接口。
2、在主方法中调用创建的方法，方法中传递需要处理的数据

3.3 注意事项

1、Consumer接口是有参数无返回值。
2、Consumer接口参数数据类型为泛型传递的数据类型。

3.4 使用格式

创建使用Consumer接口的方法：
修饰符(例如:public、private) static(在存在主函数的类中使用是存在) void 方法名(数据类型 变量名1, Consumer<数据类型> 变量名2){
变量名2.accept(变量名1);
}
调用方法：
1、使用Consumer接口实现类：
方法名(变量1, new Consumer接口实现类);
2、使用匿名内部类：
方法名(变量1, new Consumer接口<数据类型>(){
数据处理代码
});
3、使用Lambda表达式：
方法名(变量1，(变量名) -> {
数据处理代码
});

3.5 示例

创建方法：
public static void reverse(String str, Consumer<String> consumer){
        consumer.accept(str);
}
使用匿名内部类
reverse(str1, new Consumer<String>() {
    @Override
    public void accept(String s) {
        String str = new StringBuffer(s).reverse().toString();
        System.out.println(str);
    }
});
使用Lambda表达式
reverse(str1, (s)->{
      String str = new StringBuffer(s).reverse().toString();
      System.out.println(str);
});

3.6 andThen方法

功能：当需要使用多个Consumer接口时，将多个Consumer接口组合到一起使用对数据进行处理。
使用格式：
以两个Consumer接口为例：Consumer接口变量名1.andThen(Consumer接口变量名2).accept(需要处理的数据)
示例：
public static void useAndThen(String s, Consumer con1, Consumer con2){
con1.andThen(con2).accept(s);
}
注意事项：
1、Consumer接口谁在前面谁先执行。
2、最后必须接accept方法才能处理数据。

四、Predicate接口

4.1 功能

用于对数据进行判断的接口。

4.2 作为方法参数时的使用步骤

1、创建一个方法，方法中传递需要进行判断的数据和Predicate接口，Predicate接口泛型需要与进行判断的数据的数据类型相同。
2、返回predicate接口变量的test方法，test方法中传递需要进行判断的数据。
3、在调用处创建方法，方法中传递需要判断的数据和Predicate接口实例。

4.3 注意事项

1、Predicate接口的test方法会返回一个boolean类型的值作为结果。
2、调用方法时需要将Predicate接口实例化。

4.4 使用格式

创建使用Predicate接口的方法
修饰符(例如：public、private) static(根据实际情况确定是否省略) boolean 方法名(需要判断的数据, Predicate<数据类型> 变量名){
return 变量名.test(需要判断的数据)
}
调用方法
1、使用Predicate接口实现类
方法名(需要判断的数据, new Predicate接口实例类);
2、使用匿名内部类
方法名(需要判断的数据, new Predicate<数据类型>(){
@Override
public boolean test(数据类型 变量名) {
数据判断代码
return 判断的结果;
}
});
3、使用Lambda表达式
方法名(需要判断是数据, (变量名) -> {
数据判断代码
return 判断的结果
})

4.5 示例

方法的创建
    public static boolean usePredicate(String s, Predicate<String> pre){
            return pre.test(s);
    }
方法的调用
    使用匿名内部类方式
    boolean b1 =usePredicate(str1, new Predicate<String>() {
        @Override
        public boolean test(String s) {
            return s.length() > 6;
        }
    });
    使用Lambda表达式
    boolean b2 = usePredicate(str1, (t) -> {
        return t.length() > 6;
    });

4.6 and方法

功能：用于将多个Predicate接口判断的结果连接，当Predicate接口判断结果全为true时返回true，否则返回false。
使用格式：Predicate接口变量名1.and(Predicate接口变量名2).test(需要判断的数据)
示例：pre1.and(pre2).test(s);

4.7 or方法

功能：用于将多个Predicate接口判断的结果连接，当Predicate接口判断结果全为false时返回false，否则返回true。
使用格式：Predicate接口变量名1.or(Predicate接口变量名2).test(需要判断的数据)
示例：pre1.or(pre2).test(s);

4.8 !号

功能：用于将Predicate接口判断的结果取反，当Predicate接口判断结果为false时返回true，为true时返回false。
使用格式：!Predicate接口变量名1.test(需要判断的数据)
示例：!pre1.test(s);

5、Function接口

5.1 功能

数据处理后进行数据类型转换的接口。

5.2 作为方法参数时的使用步骤

1、创建方法，参数为需要转换的数据和Function接口。
2、在方法中调用Function接口的apply方法用于数据类型转换。
3、调用方法，在方法中传递需要转换的数据和Function接口功能实现代码。

5.3 注意事项

1、apply方法有返回值，返回值数据类型为转换后数据的数据类型。
2、调用方法时需要将Function接口实例化。

5.4 使用格式

创建方法格式：
修饰符(即public、private) static(根据情况决定是否数量) 返回值数据类型(如不想有数据返回使用void)
方法名(需要处理的数据, Function<转换前数据类型，转换后数据类型> 变量名1){
转换后数据类型 变量名 = 变量名1.apply(需要转换的数据);
}
使用方法格式：
1、使用Function接口实现类的方式
方法名(需要转换的数据，new Function接口实现类());
2、使用匿名内部类的方式
方法名(需要转换的数据，new Function<转换前数据类型， 转换后数据类型>(){
@Override
public 转换后的数据类型 apply(转换前的数据类型 变量名) {
数据处理代码
return 转换后的数据;
}
});
3、使用Lambda表达式的方式
方式名(需要转换的数据，(变量名) ->{
数据处理代码
return 转换后的数据;
})

5.5 使用示例

创建方法示例：
    public static void function1(String s, Function<String, Integer> fun){
            int n = fun.apply(s);
            System.out.println(n);
        }
调用方法示例：
    function1(str, new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
            return Integer.parseInt(s);
        }
    });

5.6 andThen()方法

功能：连接两个Function接口的方法。
格式：Function接口变量名1.andThen(Function接口变量名2).apply(需要转换的数据)。
示例：fun1.andThen(fun2).apply(s);