函数式接口的简单理解

最新推荐文章于 2024-03-14 17:55:16 发布

原创最新推荐文章于 2024-03-14 17:55:16 发布 · 330 阅读

0 ·

CC 4.0 BY-SA版权

简单入门java 专栏收录该内容

30 篇文章

订阅专栏

本文详细介绍了Java中的四种函数式接口：Function、Supplier、Predicate 和 Consumer。这些接口因其简洁性和功能性而在函数式编程中占据重要位置。文章通过具体示例展示了如何使用这些接口来简化代码并提高程序的灵活性。

文章目录

- - 函数式接口(都只有一个需要我们实现的方法)

函数式接口(都只有一个需要我们实现的方法)

1. 函数式接口 Function

@FunctionalInterface
public interface Function<T, R> {

    // 将此函数应用于给定的参数。
    // 传入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;
    }
}

使用

//函数式接口
// 传入 T
// 返回 R
public class functionTest {

    public static void main(String[] args) {
        //            T         R
        new Function<String, String>() {
            @Override
            public String apply(String t) {
                return "R";
            }
        };

         new Thread(() -> {
             System.out.println(123);
         });

        Function f = new Function<String, String>() {
            @Override
            public String apply(String o) {
                return "123";
            }
        };
        Function f1 = (str) -> { return str; };
        System.out.println(f1.apply("112"));
    }
}

2. 供给型接口 Supplier

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

// 供给型接口
//  无传入
//  返回T
public class supplierTest {
    public static void main(String[] args) {
        new Supplier<String>() {
            @Override
            public String get() {
                return "123";
            }
        };

        Supplier<String> supplier = () -> {return "123";};
    }
}

3. 断言型接口 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);
    }
    
}

//断言型接口
// 传入 T
// 返回一个boolean值
public class predicateTest {

    public static void main(String[] args) {

        Predicate<String> pr = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.equals("123");
            }
        };
        Predicate<String> s = (srt) -> { return srt.isEmpty();};

    }
}

4. 消费型接口 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); };
    }
}

//消费型接口
// 传入 T
// 返回void
public class consumerTest {
    public static void main(String[] args) {
        Consumer c = new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println("123");
            }
        };

        Consumer<String> s = (str) ->{
            System.out.println(123);
        };
        s.accept("789");
    }
}