博客

1 Function.apply 函数定义

@Test
public void biFunction() {
    Function<String, String> function = (name) -> {
        log.info("BiFunction 函数调用,一个参数，一个返回值");
        return "我是" + name;
    };
    String ret = function.apply("张三");
    log.info("ret：{}", ret);
    //优化版，两个参数一个返回值
    BiFunction<String, Integer, String> biFunction = (name, age) -> {
        log.info("BiFunction 函数调用,两个参数，一个返回值");
        return "我是" + name + "年龄:" + age;
    };
    ret = biFunction.apply("张三", 100);
    log.info("ret：{}", ret);
    //比较常用的方式【函数调用者自定义函数】
    divApplyFunction("张三",(name)->{
        log.info("函数调用者自定义函数");
        return "我是"+name;
    });
}

private void divApplyFunction(String name,Function<String, ?> function){
    log.info("返回结果:{}",function.apply(name));
}

2 Predicate.test 条件判断

 /**
     * 条件判断
     */
    @Test
    public void predicate() {
        Predicate<String> filter = (name) -> {
            if (name.equals("张三")) {
                return true;
            } else {
                return false;
            }
        };
        if (filter.test("张三")) {
            log.info("单参数，校验通过");
        } else {
            log.info("单参数，校验不通过");
        }
        //双参数
        BiPredicate<String, Integer> filter2 = (name, age) -> {
            if (name.equals("张三") && age == 30) {
                return true;
            } else {
                return false;
            }
        };

        if (filter2.test("张三", 30)) {
            log.info("双参数，校验通过");
        } else {
            log.info("双参数，校验不通过");
        }
        //比较常用的方式【函数调用者自定义函数】
        divBiPredicate("张三", 30, (name, age) -> {
            if (name.equals("张三") && age == 30) {
                return true;
            } else {
                return false;
            }
        });
    }

    private void divBiPredicate(String name, Integer age, BiPredicate<String, Integer> biPredicate) {
        if (biPredicate.test(name, age)) {
           log.info("校验通过,{},{}",name,age);
            divBiPredicate("李四", 25,biPredicate);
        }else {
            log.info("校验不通过,{},{}",name,age);
        }

    }

3 Consumer.accept 函数定义

 /**
     * 先定义函数内容，后进行调用
     */
    @Test
    public void consumer() {
        log.info("一个参数");
        Consumer<Student> consumer = (student) -> {
            student.setAge(30);
            student.setName("张三");
        };
        Student student = Student.builder().build();
        consumer.accept(student);
        log.info("student:{}", student);

        log.info("两个参数");
        BiConsumer<Student, String> consumer2 = (student2, s) -> {
            student2.setAge(30);
            student2.setName(s + "张三");
        };
        Student student2 = Student.builder().build();
        consumer2.accept(student2, "福建");
        log.info("student2:{}", student2);
        //比较常用的方式【函数调用者自定义函数】
        divConsumer(Student.builder().age(20).build(), (divStudent) -> {
            divStudent.setName("王五");
        });
    }

    private void divConsumer(Student student, Consumer<Student> consumer) {
        consumer.accept(student);
        log.info("student:{}", student);

    }

4 Supplier.get 函数定义

   /**
     * 读取定义对象
     */
    @Test
    public void supplier() {
        Supplier<Student> supplier = () -> {
            log.info("定义对象");
            return Student.builder().age(30).name("张三").build();
        };

        Student student = supplier.get();
        log.info("student:{}", student);
        int age=30;
        //比较常用的方式【函数调用者自定义函数】
        divSupplier("阿三",()-> Student.builder().age(age).build());
    }

    private void divSupplier(String name,Supplier<Student> supplier){
        Student student=supplier.get();
        student.setName(name);
        log.info("结果:"+student);
    }

5 Comparator比较器

//比较器
@Test
public void comparator() {
    Comparator<Integer> comparator = (num1, num2) -> {
        if (num1 == num2) {
            return 0;
        } else if (num1 > num2) {
            return 1;
        } else {
            return -1;
        }
    };

    log.info("ret:" + comparator.compare(100, 90));
    log.info("ret:" + comparator.reversed().compare(100, 90));
    log.info("ret:" + comparator.compare(100, 100));
}
//比较器
@Test
public void binaryOperator() {
    Comparator<Integer> comparator = (num1, num2) -> {
        if (num1.equals(num2)) {
            return 0;
        } else if (num1 > num2) {
            return 1;
        } else {
            return -1;
        }
    };

    int apply = BinaryOperator.maxBy(comparator).apply(100, 90);
    log.info("获取更大的:" + apply);
    apply = BinaryOperator.minBy(comparator).apply(100, 90);
    log.info("获取更小的:" + apply);
}

6 @FunctionalInterface自定义函数接口

@Slf4j
public class MyFunctionalInterfaceTest {

    /**
     * 自定义函数调用
     */
    @Test
    public void test1() {
        Students students = new Students();
        //定义需要传的参数值和函数名称
        String ret = replacePlaceholders("张三", 20, students::findName);
        log.info("函数式编程返回值：{}",ret);
    }


    private String replacePlaceholders(String name, Integer age, MyFunctionalInterfaceTest.PlaceholderResolver placeholderResolver) {
        name=name+"8080【调用函数里面修改】";
        return placeholderResolver.resolvePlaceholder(name, age);
    }

    /**
     * 被调用的类和方法
     */
    class Students {
        String findName(String name, Integer age) {
            return "姓名:" + name + ",年龄:" + age ;
        }
    }

    /**
     * 定义与被调用类绑定接口和接口函数
     */
    @FunctionalInterface
    public interface PlaceholderResolver {
        /**
         * 函数接口名称
         * @param name 11
         * @param age 22
         * @return
         */
        @Nullable
        String resolvePlaceholder(String name, Integer age);
    }
    /**
     * 自定义函数校验抛异常
     */
    @Test
    public void test2() {
        int age=80;
        MyFunctionalInterfaceTest.checkAge(age).throwException("年龄需要100岁以内");
        log.info("验证通过");
    }
    private static ThrowException checkAge(int age) {
        return msg -> {
            if (age>=100) {
                throw new RuntimeException(msg);
            }
        };
    }
    /**
     * 函数式异常抛出
     **/
    @FunctionalInterface
    public interface ThrowException {

        /**
         * 抛出异常情况
         * @param msg 异常内容
         **/
        void throwException(String msg);

    }
}

7 Optional非空校验

/**
 * 对属性判断
 */
@Test
public void test1_base() {
    //简单字符串的判空
    String name = "zhangsan";
    name = Optional.ofNullable(name).orElse("unKnow");
    log.info("nam:{}", name);
    name = null;
    name = Optional.ofNullable(name).orElse("orElse->unKnow");
    log.info("nam:{}", name);
    name = null;
    name = Optional.ofNullable(name).orElseGet(()-> "orElseGet->unKnow");
    log.info("nam:{}", name);
}

/**
 * 对象查询固定属性值
 */
@Test
public void test2_object_map(){
    String name;
    //对象判断
    Student student1 = new Student(123, "zhangsan", 30);
    Optional<Integer> optional = Optional.ofNullable(student1).flatMap((e) -> Optional.of(e.getAge()));
    log.info("name:" + optional.get());

    name = Optional.ofNullable(student1).map((v) -> v.getName()).get();
    log.info("name:" + name);

    Student student2 = new Student(111, null, 30);
    //对象的指定属性为空返回固定值
    String name2 = Optional.ofNullable(student2).map(Student::getName).orElse("unKnow");
    log.info("name2:" + name2);


}
/**
 * 空对象判断
 */
@Test
public void test3_object_null() throws Throwable{

    Student student =null;
    //当对象为空直接返回新的对象
    Student student2 = Optional.ofNullable(student).orElseGet(() -> {
        Student student3 = new Student(111, "lisi", 30);
        return student3;
    });
    log.info("student2:" + student2);

    //当对象为空直接抛异常,不为空直接返回对象
    Student student4 = Optional.ofNullable(student2).orElseThrow(() -> new Throwable("null"));
    log.info("student4:"+student4);
}
/**
 * 非空对象查询
 */
@Test
public void test4_object_null(){
    Student student1 = new Student(123, "wangwu", 30);
    //对象非空直接处理业务
    Optional.ofNullable(student1).ifPresent(u->doSomthing(student1));
}
private void doSomthing(Student student){
    log.info("student:"+student);
}