Java之Util下Function类学习

最新推荐文章于 2025-04-30 17:41:34 发布

原创最新推荐文章于 2025-04-30 17:41:34 发布 · 3k 阅读

16 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

20 篇文章

订阅专栏

本文详细介绍了Java8中Consumer、Predicate、Function和Supplier四大函数接口的使用方法与应用场景，包括接口定义、源码解析及典型实例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JAVA8的java.util.function包

Java8之Consumer、Supplier、Predicate和Function攻略

一.概述

name	type	description
Consumer	Consumer<T>	接收T对象，不返回值
Predicate	Predicate<T>	接收T对象并返回 boolean
Function	Function<T,R>	接收T对象，返回R对象
Supplier	Supplier<T>	提供对象，不接收值

二.Consumer接口

Consumer 接口就是一个消费型的接口，通过传入参数，然后输出值。

2.1 源码

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

例如 Stream 中的 foreach 方法要求传的参数就是 Consumer

483

void forEach(Consumer<? super T> action);

2.2 Consumer实例

以下是网上大佬举的例子

/**
     * consumer接口测试
     */
@Test
public void test_Consumer() {
    //① 使用consumer接口实现方法
    Consumer<String> consumer = new Consumer<String>() {

        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    Stream<String> stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
    stream.forEach(consumer);

    System.out.println("********************");

    //② 使用lambda表达式，forEach方法需要的就是一个Consumer接口
    stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
    Consumer<String> consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口
    stream.forEach(consumer1);
    //更直接的方式
    //stream.forEach((s) -> System.out.println(s));
    System.out.println("********************");

    //③ 使用方法引用，方法引用也是一个consumer
    stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
    Consumer consumer2 = System.out::println;
    stream.forEach(consumer);
    //更直接的方式
    //stream.forEach(System.out::println);
}

2.3 实例分析

① consumer接口分析

在代码①中，我们直接创建 Consumer 接口，并且实现了一个名为 accept 的方法，这个方法就是这个接口的关键了。

我们看一下 accept 方法；这个方法传入一个参数，不返回值。当我们发现 forEach 需要一个 Consumer 类型的参数的时候，传入之后，就可以输出对应的值了。

② lambda 表达式作为 consumer

Consumer<String> consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口

在上面的代码中，我们使用下面的 lambda 表达式作为 Consumer。仔细的看一下你会发现，lambda 表达式返回值就是一个 Consumer；所以，你也就能够理解为什么 forEach 方法可以使用 lamdda 表达式作为参数了吧。

③ 方法引用作为 consumer

Consumer consumer2 = System.out::println;

在上面的代码中，我们用了一个方法引用的方式作为一个 Consumer ，同时也可以传给 forEach 方法。

三.Predicate接口

Predicate 接口就是一个判断型接口，这个就是一个类似于 bool 类型的判断的接口。

3.1 源码

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

例如：Stream 中的 filter 方法

484

Stream<T> filter(Predicate<? super T> predicate);

3.2 Predicate 实例

以下实例来自网络上大佬的实例

/**
     * Predicate谓词测试，Predicate作为接口使用
     */
@Test
public void test_Predicate2() {
    //① 将Predicate作为filter接口，Predicate起到一个判断的作用
    Predicate<Integer> predicate = new Predicate<Integer>() {
        @Override
        public boolean test(Integer integer) {
            if(integer > 5){
                return true;
            }
            return false;
        }
    };

    Stream<Integer> stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
    List<Integer> list = stream.filter(predicate).collect(Collectors.toList());
    list.forEach(System.out::println);

    System.out.println("********************");

}

3.3 总结

① Predicate 是一个谓词型接口，其实只是起到一个判断作用。

② Predicate 通过实现一个 test 方法做判断。

四.Function 接口

Fuction 接口就是一个功能型接口，它的作用就是转换作用，将输入数据转换成另一种形式的输出数据。

4.1 源码

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

例如：Stream 中的 map 方法

485

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

4.2 Function 接口实例

以下实例来自网上大佬

/**
     * Function测试，function的作用是转换，将一个值转为另外一个值
     */
@Test
public void test_Function() {
    //① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型
    Function<String, Integer> function = new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
            return s.length();//获取每个字符串的长度，并且返回
        }
    };

    Stream<String> stream = Stream.of("aaa", "bbbbb", "ccccccv");
    Stream<Integer> stream1 = stream.map(function);
    stream1.forEach(System.out::println);

    System.out.println("********************");

}

以上实例可以方便的理解 Function 的作用。

4.3 总结

① Function 接口是一个功能型接口，是一个转换数据的作用。

② Function 接口实现 apply 方法来做转换。

五.Supplier

Supplier 接口就是一个供给型 的接口，就是一个容器。

5.1 源码

@FunctionalInterface
public interface Supplier<T> {

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

Optional 中有一个方法 orElseThrow 就是其应用

486

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

5.2 Supplier 实例

以下来自网上的大佬的实例

**
    * Supplier接口测试，supplier相当一个容器或者变量，可以存储值
    */
    @Test
    public void test_Supplier() {
    //① 使用Supplier接口实现方法,只有一个get方法，无参数，返回一个值
    Supplier<Integer> supplier = new Supplier<Integer>() {
        @Override
        public Integer get() {
            //返回一个随机值
            return new Random().nextInt();
        }
    };

    System.out.println(supplier.get());

    System.out.println("********************");

    //② 使用lambda表达式，
    supplier = () -> new Random().nextInt();
    System.out.println(supplier.get());
    System.out.println("********************");

    //③ 使用方法引用
    Supplier<Double> supplier2 = Math::random;
    System.out.println(supplier2.get());
}

5.3 实例分析

① Supplier接口分析

Supplier<Integer> supplier = new Supplier<Integer>() {
    @Override
    public Integer get() {
        //返回一个随机值
        return new Random().nextInt();
    }
};

看一下这段代码，我们通过创建一个 Supplier 对象，实现了一个 get 方法，这个方法无参数，返回一个值；所以，每次使用这个接口的时候都会返回一个值，并且保存在这个接口中，所以说是一个容器。

② lambda表达式作为 Supplier

//② 使用lambda表达式，
supplier = () -> new Random().nextInt();
System.out.println(supplier.get());
System.out.println("********************");

上面的这段代码，我们使用 lambda 表达式返回一个 Supplier类型的接口，然后，我们调用 get 方法就可以获取这个值了。

③ 方法引用作为 Supplier

//③ 使用方法引用
Supplier<Double> supplier2 = Math::random;
System.out.println(supplier2.get());

方法引用也是返回一个Supplier类型的接口。