jdk8 Predicate Optional Supplier Function Consumer函数 理解和应用

Predicate接口函数 ，用于评估判断自定义的test()方法。 类似bool函数。Stram中的filter()函数入参就是pridicate函数对象

即实现test()方法，到达自定义判断目的，返回boolean 参数。

测试如下：

package utils;

import javax.swing.text.Style;
import java.sql.SQLOutput;
import java.util.function.Predicate;

public class Test {
    private static String str1 ="Lile";


    public static void main(String[] args) {

        // 传统方法
        Test test  = new Test();
        System.out.println(test.isEquals("lile"));
        System.out.println(test.strLength("lile"));
        // jdk8 predicate
        System.out.println(test.testPredicate("lile",str->str.equals(str1)));
        System.out.println(test.testPredicate("lile",str->str.length()>5));
    }
    private  boolean isEquals( String str){ // 是否相等于“lile”
        return str1.equals(str);
    }
    private boolean strLength(String str){  // 长度大于5
        return str1.length()>5?true:false;
    }

    private boolean testPredicate(String str,Predicate<String> predicate){
        return predicate.test(str);
    }
}

@Test
    private void testPredicate(){
        Predicate<String> stringPredicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()>4;
            }
        };

        Stream<String> stringStream = Stream.of("abn","asdldg");
        stringStream.filter(stringPredicate); // 结果为 stream.of("asdldg");
        // 等同
        stringStream.filter(s->s.length()>4);
    }

Predicate中还有其他 方法：

and 方法的源码中，给原来的test方法&&另一个pridicate的test方法

举例：

  // test predicate and 方法：
        Predicate<String> pred1 = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.equals("Lile");
            }
        };
        Predicate<String> pre2 = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()>5;
            }
        };
        System.out.println(pred1.and(pre2).test("lile"));  // == lile && length>5
        System.out.println(pred1.or(pre2).test("lile")); // ==lile || length>5 

negate()非，or()或 同理

Optional函数

optional 通过of() ofNullable() empty()方法获取对象，通过get() orElse() orElseGet() orElseThrow()获取对象,idPresent()判断是否为null

常用与减少对象判断null的if else语句。

举例：

 Test test2 = new Test();

        if(null==test2){
            test2 = test;
        }
        // of orElse获取
        Test optionalTest = Optional.ofNullable(test2).orElse(test);

减少代码

Supplier函数

内部只有get方法，用于获取对象  ，没有输入参数。在：：new 时候不会创建T对象。 在调用get方法是时候才会创建T的对象

Optional.orElseGet方法入参就是SuppLier函数对象。

@FunctionalInterface  定义接口要求类有且只有一个抽象方法    

测试：

// test Supplier
        Supplier<Test> supplier = Test::new;  //无参构造方法
        Test test3 = supplier.get();// 获取
        Supplier<Test> supplier12 = ()->new Test(1,2); // 有参高素质
         Test test1 = supplier12.get();




@Test
    private void testSupplier(){
        // 提供获取的函数  实现get方法
        Supplier<Integer> stringSupplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return new Random().nextInt();
            }
        } ;

        Integer i=  new Integer(0);
        Optional<Integer> optionalIteger = Optional.ofNullable(i);
        System.out.println(optionalIteger.orElseGet(stringSupplier));
        // 等同于
        optionalIteger.orElseGet(()->new Random().nextInt());


    }

 

使用predicate optional supplier 创建 checker工具类

package utils;

import exceptions.UncheckedException;

import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 封装 检查类
 */
public class Checker {
    private Checker(){

    }

    /**
     * 判断为null
     * @param obj
     * @param troubleSupplier
     * @param <O>
     * @param <T>
     * @return
     */
    private static <O,T extends UncheckedException> O checkIsNull(O obj, Supplier<T> troubleSupplier){
        Objects.requireNonNull(troubleSupplier);
        if(null != obj){
            throw  troubleSupplier.get();
        }
        return null;
    }

    /**
     * 是否为null  否抛出异常
     * @param obj
     * @param troubleSupplier
     * @param <O>
     * @param <T>
     * @return
     */
    private static <O,T extends UncheckedException> O  checkNoNull(O obj,Supplier<T> troubleSupplier){
        Objects.requireNonNull(troubleSupplier);
        return Optional.ofNullable(obj).orElseThrow(troubleSupplier);
    }

    /**
     * 判断是否为true
     * @param expr
     * @param troubleSupplier
     * @param <T>
     */
    private static <T extends UncheckedException> void checkTrue(boolean expr,Supplier<T> troubleSupplier){
        Objects.requireNonNull(troubleSupplier);
        if(!expr){
            throw troubleSupplier.get();
        }
    }

    /**
     * 判断是否为false  负责抛出异常
     * @param expr
     * @param troubleSupplier
     * @param <T>
     */
    private static <T extends  UncheckedException> void checkFlase(boolean expr,Supplier<T> troubleSupplier){
        Objects.requireNonNull(troubleSupplier);
        if(expr){
             throw  troubleSupplier.get();
        }
    }

    /**
     * 判断true false
     * @param expr
     * @param troubleSupplier
     * @param <T>
     */
    public static <T extends UncheckedException> void checkFalse(boolean expr, Supplier<T> troubleSupplier) {
        Objects.requireNonNull(troubleSupplier);
        if (expr) {
            throw troubleSupplier.get();
        }
    }

    /**
     * 集合内都不符合predicate  抛出异常
     * @param items
     * @param predicate
     * @param troubleSupplier
     * @param <T>
     * @param <E>
     */
    public static <T extends UncheckedException, E> void checkEachState(
            List<E> items, Predicate<? super E> predicate, Supplier<T> troubleSupplier) {
        Objects.requireNonNull(items);
        Objects.requireNonNull(predicate);
        Objects.requireNonNull(troubleSupplier);
        if (items.stream().noneMatch(predicate)) {
            throw troubleSupplier.get();
        }
    }

    /**
     * map检查
     * @param iterable
     * @param troubleSupplier
     * @param <O>
     * @param <T>
     * @return
     */
    public static <O extends Iterable<?>, T extends UncheckedException> O checkNonEmpty(O iterable, Supplier<T> troubleSupplier) {
        Objects.requireNonNull(troubleSupplier);
        checkTrue(Optional.ofNullable(iterable).map(Iterable::iterator).map(Iterator::hasNext).orElse(false), troubleSupplier);
        return iterable;
    }
}

Function

Function函数是转换函数 ，Function<T1,T2>  然后实现apply（）方法 转换， T1为转换前的类型，T2为转换后的类型。

stream.map（） 中的传参就是实现了一个function具体看下面例子：

@Test
    private static   void testFunction(){
        // 转换函数  泛型第一个参数为转换前，第二个为转换后
        Function<String,Integer>  function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };
        Stream<String> stringStream = Stream.of("abn","asdldg");
        Stream<Integer> integerStream = stringStream.map(function);  
// 实现将int类型转换为string
        integerStream.forEach(System.out::print);


        integerStream  = stringStream.map(s->s.length());  
// 也可以直接用lambda表达式实现funtion函数
        stringStream.mapToLong(s->new Long(s));  

Consumer函数

消费性接口，听名字，就是将参数消化，为我所用 。 Stream中的 foreach（）传参就是使用了consumer的对象。

@Test
    private void testConusmer(){
        // 将入参s打印
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };

        Stream<String> stringStream = Stream.of("abn","asdldg");
        stringStream.forEach(consumer);
        // 等同
        stringStream.forEach(s-> System.out.println(s));

    }