[Java进阶学习][函数式编程][Java 8内置函数式接口]

最新推荐文章于 2024-06-22 23:38:32 发布

某魔法的一己之见

最新推荐文章于 2024-06-22 23:38:32 发布

阅读量319

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/u011863951/article/details/80906568

版权

Java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

[Java进阶学习][Java 8内置函数式接口]

[Java进阶学习][Java 8内置函数式接口]
- 简介
- JUF 函数式接口

简介

众所周知 Java8 最大的改变就是引入了Lambda表达式以实现函数式编程
Lambda到底是是什么怎么用此类文章多有赘述此处不多谈
就像Java提供了内置的强大数据结构 Java集合框架JCF
或者Java提供的强大的并发编程工具 Java并发包JUC一样
Java8 为了更好的帮助开发者进行函数式编程
JDK内置了java.util.function函数式接口包

掌握JDK提供的这些函数式接口可以更迅速有效的帮助我们编写符合Lambda表达式
和函数式编程规则的代码

JUF 函数式接口

基于 Java 9
虽然JUF提供了很多的函数式接口但大体上也就是分为以下四种类型其他的都是在这
四种类型上的扩充

接口	参数	返回值	类型
Function	T	R	函数式接口
Predicate	T	boolean	断言式接口
Consumer	T	void	消费型接口
Supplier	none	T	生产型接口

所有的函数式接口顾名思义都是接口需要传入具体的实现
这里是Lambda行为才能运行

基本接口

Function 函数式接口

Fcuntion接口是对接受一个T类型参数,返回R类型的结果的方法的抽象,通过调用apply方法执行内容

源码

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (v) -> {
            return this.apply(before.apply(v));
        };
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (t) -> {
            return after.apply(this.apply(t));
        };
    }

    static <T> Function<T, T> identity() {
        return (t) -> {
            return t;
        };
    }
}

从源码上看 Function接口还是比较简单的
只有一个主方法所以类上加注了@FunctionalInterface函数式接口注解

R apply(T t);

此方法接收一个泛型参数T t 进行处理后返回泛型结果R
Function接口接收一个Lambda行为，apply方法应用此行为进行处理和数据转换
还可以配合默认方法compose，andThen进行链式调用进行多级处理
实现更复杂和丰富的功能

使用方法示例

先编写一个以Function为参数可以传入函数式行为的方法

   public int compute(int a, Function<Integer, Integer> function) {
        int result = function.apply(a);
        return result;
    }

然后调用此方法传入具体的lambda表达式

     System.out.println(this.compute(1,x->x+7));
     System.out.println(this.compute(1,x->x-1));
     System.out.println(this.compute(2,x->x*x));

结果

8
0
4

apply()方法应用了传入的行为进行了运算并返回处理结果

上面的是进行计算还可以指定不同的T,R类型比如数据类型转换

public static Integer convert(String str, Function<String, Integer> function) {
    return function.apply(str);
}

转换操作

Integer value = convert("28", x -> Integer.parseInt(x));

返回了一个整型 28

链式调用

使用Function的默认方法可以链式的调用一系列的Function接口的行为

写两个多重计算的方法
第一个使用了默认方法

default < V> Function< V, R> compose(Function< ? super V, ? extends T> before)

此默认方法会先处理传入的before行为再运行之后的操作
所以 multiCompute泛型方法中会先处理before中的行为再应用after的行为

     public <T> T multiCompute(T a,Function<T,T> before,Function<T,T> after) {
      return after.compose(before).apply(a);
    }

第二个使用了默认方法

default < V> Function< T, V> andThen(Function< ? super R, ? extends V> after)

此默认方法会一般被其他函数式行为调用执行时先执行调用者自身的行为内容
再执行andThen方法传入的行为内容
所以multiCompute2泛型方法会先运行before的行为再执行after的行为

    public <T> T multiCompute2(T a,Function<T,T> before,Function<T,T> after) {
        return before.andThen(after).apply(a);
    }

测试

        int result=this.multiCompute(5,x->x*2,x->x*x);
        System.out.println("result="+result);
        int result2=this.multiCompute2(5,x->x*2,x->x*x);
        System.out.println("result2="+result2);

结果

result=50
result2=100

另外Function接口还有一个静态方法identity() 返回元素本身

static <T> Function<T, T> identity() {
        return t -> t;
    }

这个方法主要用在不需要对数据处理的行为中等同于lambda表达式 x->x

以下代码时等价的

        list.stream().map(x->x);
        list.stream().map(Function.identity());

Predicate 断言式接口

源码

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> {
            return this.test(t) && other.test(t);
        };
    }

    default Predicate<T> negate() {
        return (t) -> {
            return !this.test(t);
        };
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> {
            return this.test(t) || other.test(t);
        };
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return null == targetRef ? Objects::isNull : (object) -> {
            return targetRef.equals(object);
        };
    }
}

和Function接口一样Predicate断言式接口作为一个函数是接口
只有一个方法

boolean test(T t);

一个断言式接口接受一个lambda包含判断的行为调用test方法返回判断结果的逻辑真假值

编写一个断言方法

    public <T> List<T> filter(List<T> list,Predicate<T> predicate) {

        List<T> result=new ArrayList<>(list.size());

        list.forEach(x->{

            if(predicate.test(x))
                result.add(x);
        });
        return result;
    }

调用

   List<String> list=Stream
        .of("apple","banana","coconut","Damson","Filbert","Lemon"，)
        .collect(Collectors.toList());

        List newList=this.filter(list,x->x.startsWith("a"));
        newList.forEach(System.out::println);
        //结果 apple

一般此接口常用在Stream流中调用用以过滤流内容

   List<String> list=Stream.of("apple","banana","coconut","Damson","Filbert","Lemon")
                .collect(Collectors.toList());

   list.stream().filter(x->x.startsWith("a")).forEach(System.out::println);
   //输出结果 apple

Predicate接口还提供了三个默认方法 and(),or(),negate()
顾名思义这三个默认方法是和与否定用于生成一组组合的判断行为

组合判断

主代码

  List newList = this.filterCombination(list, x -> x.contains("e"), x -> x.length() < 6);
        newList.forEach(System.out::println);

和断言

    public <T> List<T> filterCombination(List<T> list,Predicate<T> first,Predicate<T> last) {

        List<T> result=new ArrayList<>(list.size());

        list.forEach(x->{

            if(first.and(last).test(x))
                result.add(x);
        });
        return result;
    }

调用结果

apple
Lemon

上面的判断后继续调用negate()方法即可获得相反的断言内容

否断言

    public <T> List<T> filterCombination(List<T> list,Predicate<T> first,Predicate<T> last) {
        List<T> result=new ArrayList<>(list.size());
        list.forEach(x->{
            if(first.and(last).negate().test(x))
                result.add(x);
        });
        return result;
    }

结果刚好和上面的和断言结果是反的

banana
coconut
Damson
Filbert

或断言

主代码

  List<String> list=Stream.of("apple","banana","coconut","Damson","Filbert","Lemon").collect(Collectors.toList());

        List newList = this.filterCombination(list, x -> x.contains("a"), x -> x.length() < 6);
        newList.forEach(System.out::println);

断言

 public <T> List<T> filterCombination(List<T> list,Predicate<T> first,Predicate<T> last) {
        List<T> result=new ArrayList<>(list.size());
        list.forEach(x->{
            if(first.or(last).test(x))
                result.add(x);
        });
        return result;
    }

结果

apple
banana
Damson
Lemon

和Function接口一样 Predicat接口也有一个静态方法

   static <T> Predicate<T> isEqual(Object targetRef) {
        return null == targetRef ? Objects::isNull : (object) -> {
            return targetRef.equals(object);
        };
    }

此方法返回了一个Predicate断言行为行为内容是使用的targetRef值相等判断
内部调用了targetRef的equals方法如果targetRef重写了equals方法则调用重写后的方法
否则调用Object的equals方法

比较不容易懂结合示例看

String str="test";
Predicate.isEqual(str).test("test")

此处即Predicate接口调用了str的equals方法判断其是否和”test”字符串相等
自然是返回true

Consumer 消费型接口

Consumer 翻译过来就是消费者,顾名思义，该接口对应的方法类型为接收一个参数，没有返回值。也就是说此接口将传入参数’消费掉了’，一般来说使用Consumer接口往往伴随着一些期望状态的改变或者事件的发生,例如最典型的forEach就是使用的Consumer接口，虽然没有任何的返回值，但是对传入的参数进行了处理。

public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

源码很简单一个接受行为并处理的accept()方法

void accept(T t);

另外还有一个默认方法andThen()
显然是用于组合链式调用

示例

List<String> list=Stream.of("apple","banana","coconut","Damson","Filbert","Lemon").collect(Collectors.toList());

        this.Consuming(list,x-> System.out.println(x));

运行结果

apple
banana
coconut
Damson
Filbert
Lemon

这个接口最多的应用在Stream流或者集合列表中的forEach方法
进行数据处理中一般不用自己写

Supplier 生产型接口

生产型接口和其他几个函数是接口都不同
相比消费型接口的只接受不返回值
此接口无输入值但有返回值
类似生产者所以命名为生产型接口

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

通常用于配合其他Lambda方法使用

比如配合Optional使用

 Optional.ofNullable(list).orElseGet(()->new ArrayList<>());

Optional的orElseGet方法接受一个Supplier参数

orElseGet(Supplier< ? extends T> supplier)

此处以lambda的形式新构造了一个空的ArrayList

拓展接口

基础接口的返回值限定扩展接口

类似Stream有四种基本Stream 和限定入参类型的IntStream DoubleStream LongStream

所有的函数是接口除了基本的T泛型接口外也有三种Int，Long，Double扩展接口
这三种接口和基本泛型接口不同的地方就是限定了入参类型甚至限定了返回值类型

Function扩展

看Function接口源码

public interface Function<T, R> {

    R apply(T t);

    ……
}

有两个泛型声明 T，R
apply方法入参T 返回R
那么其拓展方法就很容易理解了

?Function就是限定入参T为?类型
例如IntFunction

public interface IntFunction<R> {

    R apply(int value);
}

限定入参为 int型返回类型为泛型R型

To?Function就是限定返回类型为?类型
例如ToLongFunction

public interface ToLongFunction<T> {
    long applyAsLong(T t);
}

入参为泛型T不变返回值限定为long型

?To*Function就是限定入参T为?类型返回值为*类型
例如DoubleToIntFunction

public interface DoubleToIntFunction {
    int applyAsInt(double d);
}

限定入参为 double型返回类型为int型

Prdicate扩展

Predicate
|—–IntPredicate
|—–LongPredicate
|—–DoublePredicate

和Function琳琅满目的扩展不同 Predicate接口因为返回值已经限定为boolean类型
所以只有三种扩展接口
分别限定了入参类型为Int Long Double

例 IntFunction

public interface IntPredicate {

    boolean test(int value);
}

Consumer扩展

Consumer
|—–IntConsumer
|—–LongConsumer
|—–DoubleConsumer

类似Predicate接口因为返回值已经限定为void类型
所以只有三种扩展接口
分别限定了入参类型为Int Long Double

例如IntConsumer

public interface IntConsumer {

    void accept(int value);
}

限定入参为int型

但是Consumer有三个外延的接口
ObjIntConsumer
ObjDoubleConsumer
ObjLongConsumer

这三个接口可以同时接收两个参数一个T类型另一个则为Obj?Consumer的?类型
例如ObjDoubleConsumer

@FunctionalInterface
public interface ObjDoubleConsumer<T> {
    void accept(T t, double value);
}

Supplier 扩展

Supplier
|—–IntSupplier
|—–LongSupplier
|—–DoubleSupplier

类似Predicate接口因为入参已经限定为void类型
所以只有三种扩展接口
分别限定了返回类型为Int Long Double

例如 DoubleSupplier

@FunctionalInterface
public interface DoubleSupplier {
    double getAsDouble();
}

返回值类型已经限定为double类型

基础接口的入参二元扩展接口

有些基础接口的扩展接口在原有的参数之外再接收一个参数
此类接口的所有名字前面都是附加上Bi,是Binary的缩写意思是二元的双重的
例如BiPredicate,BiFcuntion等等,而由于java没有多返回值的设定，所以Bi指的都是参数为两个

接口名
BiConsumer
BiFunction
BiPredicate
ToDoubleBiFunction
ToIntBiFunction
ToLongBiFunction

可以看到这里面扩展接口是以Function为主
以BiFunction为例

源码

public interface BiFunction<T, U, R> {

    R apply(T t, U u);
}

和Function不同的就是入参变为两个 T t,U u

代码示例

    BiFunction<Integer,Integer,Integer> biFunction=(x,y)->(x+y+y);
    int res=biFunction.apply(1,2);
    System.out.println(res);
   //结果5

BiPredicate 示例

        BiPredicate<Integer,Integer> biPredicate=(i,j)->(i+j>2);

        boolean result=biPredicate.test(1,2);
        System.out.println(result);// true

操作型扩展

此类接口只有2个

接口名	描述
UnaryOperator	一元操作符
BinaryOperator	二元操作符

看UnaryOperator的源码

public interface UnaryOperator<T> extends Function<T, T> {

    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

很明显可以看出是继承自Function< T, R>接口
只不过将返回值也统一化为T 即入参和返回值都是T类型
这类接口属于Function接口的简写，他们只有一个泛型参数
意思是Funtion的参数与返回值类型相同,一般多用于操作计算
比如计算 a + b的BiFcuntion如果限制入参和返回值为Integer的话则是这样的
BiFunction<Integer,Integer,Integer>
前2个泛型代表参数，最后一个代表返回值有些过于繁琐
这个时候就可以用BinaryOperator<Integer>来代替了。