jdk8函数式接口

一、Consumer 消费型接口

/**
 * Consumer函数式接口测试
 */
@Test
public void testFunction01(){
    // 创建字符串对象
    StringBuilder sb = new StringBuilder("字符串后面将会跟随===");
    // 声明函数对象 consumer
    Consumer<StringBuilder> consumer = (str) -> str.append("java");
    // 调用Consumer.accept()方法接收参数
    consumer.accept(sb);
    System.out.println(sb.toString());
}

打印结果

字符串后面将会跟随====java

结论：Consumer类中只有一个方法，使用lambda定义accept（）方法规则，当调用accept（）方法后就会执行此方法规则。

二、BiConsumer<T, U> 接口

BiConsumer与Consumer类似。是对T,U两个参数进行规则处理

@Test
public void testFunction02(){
    // 创建字符串对象
    StringBuilder sb = new StringBuilder();
    // 声明函数对象 consumer
    BiConsumer<String,String> consumer = (str1, str2) -> {
        // 拼接字符串
        sb.append(str1);
        sb.append(str2);
    };
    // 调用Consumer.accept()方法接收参数
    consumer.accept("我是参数01，我是参数02,","我们被BiConsumer处理");
    System.out.println(sb);
}

打印结果

我是参数01，我是参数02,我们被BiConsumer处理

三、Supplier 供给型接口

supplier
英 [səˈplaɪə®] 美 [səˈplaɪər]
n.
供应商;供应国;供应者，供给者;补充者

看语义，可以看到，这个接口是一个提供者的意思，只有一个get的抽象类，没有默认的方法以及静态的方法，传入一个泛型T的，get方法，返回一个泛型T

来个例子

void testSupplier1() {
        Supplier<String> supplier = () -> "这是你要的字符串";
        String str = supplier.get();
        System.out.println("str = " + str);
    }

str = 这是你要的字符串

再来个例子

void testSupplier2() {
        Supplier<Person> supplier = () -> {
            Person person = new Person();
            person.setName("张三");
            person.setSize(32);
            return person;
        };
 
        Person person = supplier.get();
        System.out.println("person = " + person);
    }

person = Person{name='张三', size=32}

参考文献：
链接: JDK1.8 函数式接口 Consumer & Supplier.

四、Function<T,R> 函数型接口

Funtion接口，定义了一个apply的抽象方法，接收一个泛型T对象，并且返回泛型R对象，看到这里，是不是对这个接口的描述，还是一头雾水呢，下面，我们看下几个例子，来讲述这个接口的作用

       Function<Integer, Integer> function1 = x -> x * 2;
        System.out.println(function1.apply(4));// 8
 
        Function<Integer, String> function2 = x -> x * 2 + "dd";
        System.out.println(function2.apply(4));//8dd
        
        Function<String, String> strFunction1 = (str) -> new String(str);
        System.out.println(strFunction1.apply("aa"));//aa
        
        Function<String, String> strFunction2 = String::new;
        System.out.println(strFunction2.apply("bb"));//bb
 
        Function<String, Emp> objFunction1 = (str) -> new Emp(str);
        System.out.println(objFunction1.apply("cc").getName());//cc
        
        Function<String, Emp> objFunction2 = Emp::new;
        System.out.println(objFunction2.apply("dd").getName());//dd

调用apply（）方法，传参是Function<T,R>中的T泛型，返回的类型是Function<T,R>中的R泛型。

下面我们看下Funtion这个接口的“扩展”的原始类型特化的一些函数接口

IntFunction,IntToDoubleFunction,IntToLongFunction,LongFunction,LongToDoubleFunction,LongToIntFunction,DoubleFunction,ToIntFunction,ToDoubleFunction,ToLongFunction

我们知道，我们在做基础数据处理的时候（eg: Integer i=0; Integer dd= i+1;）,会对基础类型的包装类，进行拆箱的操作，转成基本类型，再做运算处理，拆箱和装箱，其实是非常消耗性能的，尤其是在大量数据运算的时候；这些特殊的Function函数式接口，根据不同的类型，避免了拆箱和装箱的操作，从而提高程序的运行效率

五、UnaryOperator 接口

UnaryOperator 接口继承了Function<T,R>接口，与Function<T,R>不同的是，它传入和返回的类型是相同的

UnaryOperator<Integer> dda = x -> x + 1;
		System.out.println(dda.apply(10));// 11
		UnaryOperator<String> ddb = x -> x + 1;
		System.out.println(ddb.apply("aa"));// aa1

这个接口，只接收一个泛型参数T，集成Function接口，也就是说，传入泛型T类型的参数，调用apply后，返回也T类型的参数；这个接口定义了一个静态方法，返回泛型对象的本身；

六、Predicate 断言型接口，或者判断型的接口

Predicate 用于做判断的接口，主要方法是test方法，要重写判断规则。

	//传入一个字符串，test方法判断该字符串长度是否大于2
    @Test
    public void test1(){
        Predicate<String> predicate = (s) -> s.length() > 2;
        boolean foo = predicate.test("foo");// true
   }

and方法
源码

default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
        //通过源码我们可以看到，return最总返回的是并且的逻辑，必须满足两个条件,等同于我们的逻辑与&&,存在短路特性
    }

	//通过调用下面的方法，我们将and和test方法连续使用
        boolean b = testAndMethod("zhangssss",
                stringOne -> stringOne.equals("zhangsan"), stringTwo -> stringTwo.length() > 5);
        System.out.println("测试and方法打印结果："+b);

    /**
     *
     * @param stringOne         待判断的字符串
     * @param predicateOne      断定表达式1
     * @param predicateTwo      断定表达式2
     * @return                    是否满足两个条件
     */
    public boolean testAndMethod(String stringOne, Predicate<String> predicateOne,Predicate<String> predicateTwo) {

        return predicateOne.and(predicateTwo).test(stringOne);//and 方法返回一个Predicate<? super T>
    }
打印结果：
	测试and方法打印结果：false 
	因为使用and方法同时需要满足两个条件