Java8之Consumer、Supplier、Predicate和Function攻略-魔扣目錄

來聊聊Consumer、Supplier、Predicate、Function這幾個接口的用法，在 JAVA8 的用法當中，這幾個接口雖然沒有明目張膽的使用，但是，卻是潤物細無聲的。為什么這么說呢？

這幾個接口都在 java.util.function 包下的，分別是Consumer（消費型）、supplier（供給型）、predicate（謂詞型）、function（功能性），相信有了后面的解釋，你應該非常清楚這個接口的功能了。

那么，下面，我們從具體的應用場景來講講這個接口的用法！

1 Consumer接口

從字面意思上我們就可以看得出啦，consumer接口就是一個消費型的接口，通過傳入參數，然后輸出值，就是這么簡單，Java8 的一些方法看起來很抽象，其實，只要你理解了就覺得很好用，并且非常的簡單。

我們下面就先看一個例子，然后再來分析這個接口。

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

輸出結果

Java8之Consumer、Supplier、Predicate和Function攻略，建議收藏

1.2 實例分析

① 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 方法。

1.3 其他 Consumer 接口

除了上面使用的 Consumer 接口，還可以使用下面這些 Consumer 接口。 IntConsumer、DoubleConsumer、LongConsumer、BiConsumer，使用方法和上面一樣。

1.4 Consumer 總結

看完上面的實例我們可以總結為幾點。

① Consumer是一個接口，并且只要實現一個 accept 方法，就可以作為一個**“消費者”**輸出信息。 ② 其實，lambda 表達式、方法引用的返回值都是 Consumer 類型，所以，他們能夠作為 forEach 方法的參數，并且輸出一個值。

2 Supplier 接口

Supplier 接口是一個供給型的接口，其實，說白了就是一個容器，可以用來存儲數據，然后可以供其他方法使用的這么一個接口，是不是很明白了，如果還是不明白，看看下面的例子，一定徹底搞懂！

2.1 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());
 }

輸出結果

2.2 實例分析

① 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類型的接口。

2.3 Supplier 實例2

我們看完第一個實例之后，我們應該有一個了解了，下面再看一個。

/**
 * Supplier接口測試2，使用需要Supplier的接口方法
 */
 @Test
 public void test_Supplier2() {
 Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
 //返回一個optional對象
 Optional<Integer> first = stream.filter(i -> i > 4)
 .findFirst();
 //optional對象有需要Supplier接口的方法
 //orElse，如果first中存在數，就返回這個數，如果不存在，就放回傳入的數
 System.out.println(first.orElse(1));
 System.out.println(first.orElse(7));
 System.out.println("********************");
 Supplier<Integer> supplier = new Supplier<Integer>() {
 @Override
 public Integer get() {
 //返回一個隨機值
 return new Random().nextInt();
 }
 };
 //orElseGet，如果first中存在數，就返回這個數，如果不存在，就返回supplier返回的值
 System.out.println(first.orElseGet(supplier));
 }

輸出結果

代碼分析

Optional<Integer>%20first%20=%20stream.filter(i%20->%20i%20>%204)
%20.findFirst();

使用這個方法獲取到一個%20Optional%20對象，然后，在%20Optional%20對象中有%20orElse%20方法%20和%20orElseGet%20是需要一個%20Supplier%20接口的。

//optional對象有需要Supplier接口的方法
%20//orElse，如果first中存在數，就返回這個數，如果不存在，就放回傳入的數
%20System.out.println(first.orElse(1));
%20System.out.println(first.orElse(7));
%20System.out.println("********************");
%20Supplier<Integer>%20supplier%20=%20new%20Supplier<Integer>()%20{
%20@Override
%20public%20Integer%20get()%20{
%20//返回一個隨機值
%20return%20new%20Random().nextInt();
%20}
%20};
%20//orElseGet，如果first中存在數，就返回這個數，如果不存在，就返回supplier返回的值
%20System.out.println(first.orElseGet(supplier));

orElse：如果first中存在數，就返回這個數，如果不存在，就放回傳入的數
orElseGet：如果first中存在數，就返回這個數，如果不存在，就返回supplier返回的值

2.4%20其他%20Supplier%20接口

除了上面使用的%20Supplier%20接口，還可以使用下面這些%20Supplier%20接口。%20IntSupplier%20、DoubleSupplier%20、LongSupplier%20、BooleanSupplier，使用方法和上面一樣。

2.5%20Supplier%20總結

①%20Supplier%20接口可以理解為一個容器，用于裝數據的。%20②%20Supplier%20接口有一個%20get%20方法，可以返回值。

3%20Predicate%20接口

Predicate%20接口是一個謂詞型接口，其實，這個就是一個類似于%20bool%20類型的判斷的接口，后面看看就明白了。

3.1%20Predicate%20實例

/**
%20*%20Predicate謂詞測試，謂詞其實就是一個判斷的作用類似bool的作用
%20*/
%20@Test
%20public%20void%20test_Predicate()%20{
%20//①%20使用Predicate接口實現方法,只有一個test方法，傳入一個參數，返回一個bool值
%20Predicate<Integer>%20predicate%20=%20new%20Predicate<Integer>()%20{
%20@Override
%20public%20boolean%20test(Integer%20integer)%20{
%20if(integer%20>%205){
%20return%20true;
%20}
%20return%20false;
%20}
%20};
%20System.out.println(predicate.test(6));
%20System.out.println("********************");
%20//②%20使用lambda表達式，
%20predicate%20=%20(t)%20->%20t%20>%205;
%20System.out.println(predicate.test(1));
%20System.out.println("********************");
%20}

輸出結果

3.2 實例分析

① Predicate 接口分析

//① 使用Predicate接口實現方法,只有一個test方法，傳入一個參數，返回一個bool值
 Predicate<Integer> predicate = new Predicate<Integer>() {
 @Override
 public boolean test(Integer integer) {
 if(integer > 5){
 return true;
 }
 return false;
 }
 };

這段代碼中，創建了一個 Predicate 接口對象，其中，實現類 test 方法，需要傳入一個參數，并且返回一個 bool 值，所以這個接口作用就是判斷！

System.out.println(predicate.test(6));

再看，調用 test 方法，傳入一個值，就會返回一個 bool 值。

② 使用lambda表達式作為 predicate

//② 使用lambda表達式，
 predicate = (t) -> t > 5;
 System.out.println(predicate.test(1));
 System.out.println("********************");

lambda 表達式返回一個 Predicate 接口，然后調用 test 方法！

3.3 Predicate 接口實例2

/**
 * 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("********************");
 }

輸出結果

這段代碼，首先創建一個 Predicate 對象，然后實現 test 方法，在 test 方法中做一個判斷：如果傳入的參數大于 5 ，就返回 true，否則返回 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);

這段代碼調用 Stream 的 filter 方法，filter 方法需要的參數就是 Predicate 接口，所以在這里只要大于 5 的數據就會輸出。

3.4 Predicate 接口總結

① Predicate 是一個謂詞型接口，其實只是起到一個判斷作用。 ② Predicate 通過實現一個 test 方法做判斷。

4 Function 接口

Function 接口是一個功能型接口，它的一個作用就是轉換作用，將輸入數據轉換成另一種形式的輸出數據。

4.1 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("********************");
 }

輸出結果

4.2 代碼分析

① Function 接口分析

//① 使用map方法，泛型的第一個參數是轉換前的類型，第二個是轉化后的類型
 Function<String, Integer> function = new Function<String, Integer>() {
 @Override
 public Integer apply(String s) {
 return s.length();//獲取每個字符串的長度，并且返回
 }
 };

這段代碼創建了一個 Function 接口對象，實現了一個 apply 方法，這個方法有一個輸入參數和一個輸出參數。其中，泛型的第一個參數是轉換前的類型，第二個是轉化后的類型。

在上面的代碼中，就是獲取字符串的長度，然后將每個字符串的長度作為返回值返回。

② 重要應用 map 方法

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

在 Function 接口的重要應用不得不說 Stream 類的 map 方法了，map 方法傳入一個 Function 接口，返回一個轉換后的 Stream類。

4.3 其他 Function 接口

除了上面使用的 Function 接口，還可以使用下面這些 Function 接口。 IntFunction 、DoubleFunction 、LongFunction 、ToIntFunction 、ToDoubleFunction 、DoubleToIntFunction 等等，使用方法和上面一樣。

4.4 Function 接口總結

① Function 接口是一個功能型接口，是一個轉換數據的作用。 ② Function 接口實現 apply 方法來做轉換。

5 總結

通過前面的介紹，已經對Consumer、Supplier、Predicate、Function這幾個接口有詳細的了解了，其實，這幾個接口并不是很難，只是有點抽象，多加理解會發現很簡單，并且特別好用！

本文到這里就結束了，喜歡的朋友可以幫忙轉發和關注一下，感謝支持！文章有不當之處，歡迎指正！