java8新特性-四大函数式接口（ConsumerSupplierFunctionPredicate）使用样例

Posted 2022-01-18 、Dong

文章目录

• 前言
• 一、Consumer：消费型接口
• 二、Supplier：供给型接口
• 三、Function：函数型接口
• 四、Predicate：断言型接口
• 结尾

---

前言

函数式接口(Functional Interface)是Java 8对一类特殊类型的接口的称呼。 这类接口只定义了唯一的抽象方法的接口，并且这类接口使用了@FunctionalInterface进行注解。在jdk8中，引入了一个新的包java.util.function, 可以使java 8 的函数式编程变得更加简便。

java.util.function包中所有的接口整理：

本篇主要讲解四大常用函数式接口：

---

一、Consumer：消费型接口

package functional;


import java.util.function.Consumer;
import java.util.stream.Stream;

/**
 * FunctionalInterface Consumer test
 *
 * @author dd
 * @since 2021/12/14
 */
public class ConsumerTest 
    private static Stream stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");

    /**
     * 常规接口实现写法
     */
    public static void test1() 
        Consumer consumer = new Consumer() 
            @Override
            public void accept(Object o) 
                System.out.println(o.toString());
            
        ;
        stream.forEach(consumer);
    

    /**
     * 函数式接口实现写法
     */
    public static void test2() 
        Consumer consumer = (s) -> System.out.println(s.toString());
        stream.forEach(consumer);
    

    /**
     * 函数式接口简化写法
     */
    public static void test3() 
        stream.forEach((s) -> System.out.println(s.toString()));
    

    /**
     * 函数式接口方法引用实现写法
     */
    public static void test4() 
        Consumer consumer = System.out::println;
        stream.forEach(consumer);
    

    /**
     * 函数式接口方法引用实现简化写法
     */
    public static void test5() 
        stream.forEach(System.out::println);
    

---

二、Supplier：供给型接口

package functional;

import java.util.Random;
import java.util.function.Supplier;

/**
 * FunctionalInterface Supplier test
 *
 * @author dd
 * @since 2021/12/14
 */
public class SupplierTest 

    /**
     * 常规接口实现写法
     */
    public static void test1() 
        Supplier supplier = new Supplier() 
            @Override
            public Object get() 
                return new Random().nextInt();
            
        ;
        System.out.println(supplier.get());
    

    /**
     * 函数式接口实现写法
     */
    public static void test2() 
        Supplier supplier = () -> new Random().nextInt();
        System.out.println(supplier.get());
    

    /**
     * 函数式接口方法引用实现写法
     */
    public static void test3() 
        Supplier supplier = Math::random;
        System.out.println(supplier.get());
    

---

三、Function：函数型接口

package functional;

import java.util.function.Function;
import java.util.stream.Stream;

/**
 * FunctionalInterface function test
 *
 * @author dd
 * @since 2021/12/14
 */
public class FunctionTest 
    private static Stream stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");

    /**
     * 常规接口实现写法
     */
    public static void test1() 
        Function function = new Function() 
            @Override
            public Object apply(Object o) 
                return o.hashCode();
            
        ;
        System.out.println(function.apply("dd"));
    

    /**
     * 函数式接口实现写法
     */
    public static void test2() 
        Function function = (s) -> s.hashCode();
        System.out.println(function.apply("dd"));
    
    /**
     * 函数式接口
     * stream应用
     */
    public static void test3() 
        Function function = (s) -> s.hashCode();
        Stream mapStream = stream.map(function);
        mapStream.forEach(System.out::println);
    

    public static void main(String[] args) 
        FunctionTest.test3();
    

---

四、Predicate：断言型接口

package functional;

import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * FunctionalInterface Predicate test
 *
 * @author dd
 * @since 2021/12/14
 */
public class PredicateTest 
    private static Stream stream = Stream.of(3, 4, 5, 6, 7);

    /**
     * 常规接口实现写法
     */
    public static void test1() 
        Predicate predicate = new Predicate() 
            @Override
            public boolean test(Object o) 
                return (int) o > 5;
            
        ;
        System.out.println(predicate.test(6));
    
    /**
     * 函数式接口实现写法
     */
    public static void test2() 
        Predicate predicate = (s) -> (int) s > 5;
        System.out.println(predicate.test(6));
    
    /**
     * 函数式接口
     * stream应用
     */
    public static void test3() 
        long count = stream.filter((s) -> (int) s > 5).count();
        System.out.println(count);
    

    public static void main(String[] args) 
        PredicateTest.test3();
    

---

结尾

• 感谢大家的耐心阅读，如有建议请私信或评论留言。
• 如有收获，劳烦支持，关注、点赞、评论、收藏均可，博主会经常更新，与大家共同进步