java 函数式接口的认识与使用

骑猪看日落 2023-07-17 04:39 11阅读 0赞

### 前言 ###

函数式接口是java 8之后的新特性，什么是函数式接口呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70]

> 函数式接口，就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

函数式接口在java中其实有很多，例如Runnable接口，在接口上的注解`@FunctionalInterface`就是用来声明这是一个函数式接口。

@FunctionalInterface
    public interface Runnable {
        
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see     java.lang.Thread#run()
         */
        public abstract void run();
    }

### 组成部分 ###

函数式接口有很多，我很难说完,例如下面是jdk官方文档给出的各种函数时接口。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 1]

这里给大家介绍这四个:函数型接口、断定型接口、消费型接口、供给型接口。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 2]

其实通过名字就可以大致知道这四个各自的作用与区别。

#### 1.函数型接口:`Function` ####

@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 v) -> apply(before.apply(v));
        }
    
        
        default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        
            Objects.requireNonNull(after);
            return (T t) -> after.apply(apply(t));
        }
    
        
        static <T> Function<T, T> identity() {
        
            return t -> t;
        }
    }

上面是函数型接口Funtion的源码，只有一个抽象方法- `apply()`,该方法有一个输入一个输出。剩下的是一些默认方法。

**简单使用Funtion接口**

//函数型接口，一个输入一个输出
            Function<String, String> function = new Function<String, String>() {
        
                @Override
                public String apply(String s) {
        
                    return s+",世界";
                }
            };
            
            System.out.println(function.apply("你好"));

在上面的代码中，我们声明一个函数型接口，并且指定输入和输出的结果都是String类型。 然后传参一个，它也会像函数那样根据我们设定的返回值类型来返回结果。  
最终返回结果:

你好,世界

#### 2.断定式接口:`Predicate` ####

@FunctionalInterface
    public interface Predicate<T> {
        
    
       
        boolean test(T t);
    
        
        default Predicate<T> and(Predicate<? super T> other) {
        
            Objects.requireNonNull(other);
            return (t) -> test(t) && other.test(t);
        }
    
      
        default Predicate<T> negate() {
        
            return (t) -> !test(t);
        }
    
       
        default Predicate<T> or(Predicate<? super T> other) {
        
            Objects.requireNonNull(other);
            return (t) -> test(t) || other.test(t);
        }
    
        
        static <T> Predicate<T> isEqual(Object targetRef) {
        
            return (null == targetRef)
                    ? Objects::isNull
                    : object -> targetRef.equals(object);
        }
    }

上面是断定型接口的源码，我们给它一个输出，它会给我们一个固定为boolean类型的返回值，这也印证了“断定”这样一个概念。

//断定型接口,有一个参数，返回值是固定的，即boolean类型
            Predicate predicate = new Predicate<String>() {
        
                @Override
                public boolean test(String s) {
        
                    if(s.equals("你好"))
                    {
        
                        return true;
                    }
                    return false;
                }
            };
    
            System.out.println(predicate.test("你好"));

上面的代码中，我们书写逻辑，如果传入的字符串是“你好”，那么就返回true。  
最终返回结果如下：

true

#### 3.消费型接口:`Consumer` ####

@FunctionalInterface
    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); };
        }
    }

上面是消费型接口:`Consumer`的源码，只有一个输入，而且可以看到，输出类型是void，这也印证了它只管“消费”，不管返回这样一个概念。

//消费型接口,一个输入，没有输出
            Consumer consumer = new Consumer<String>() {
        
                @Override
                public void accept(String o) {
        
                    System.out.println(o+":已被消费");
    
                }
            };
            consumer.accept("你好世界");

最终输出结果:

你好世界:已被消费

#### 4.供给型接口:`Supplier` ####

@FunctionalInterface
    public interface Supplier<T> {
        
    
        /**
         * Gets a result.
         *
         * @return a result
         */
        T get();
    }

上面是供给型接口`Supplier`的源码，只有一个返回值，没有输入，参数也是我们用来指定返回值类型的。 与前面消费型接口相比，是不是很有对比性，这个接口只管供给，而前面的消费型接口只管消费。

//供给型接口,没有输入，只有输出，可以指定输出的类型
            Supplier supplier = new Supplier<String>() {
        
                @Override
                public String get() {
        
                    return "供给消息:你好世界";
                }
            };
            System.out.println(supplier.get());

最终输出结果

供给消息:你好世界

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70]: /images/20230528/9e78d342192a4849bd51f215ba134755.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/2bc5eda8740648c9918eb97b1d6bef38.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/4abb983dfdc441449a81adc8525fab42.png