lambda函数式编程实践--第一篇

   偶然跟着网上看了jdk一点源码，发现jdk8之后新加的功能都是用函数式编程，看着很高大上啊，然后就想着学习学习，等到我学习了，函数式编程发现真的很强大的，能简化的代码，用着方便，像集合这样的需要循环获取，那么使用lambda可能就是一行代码的事情，这样你的代码也比较高大上，废话不多说了，开始实践吧！

1.先来学习一下Optional，是用于简化java对空值的判断处理，以防止出现各种空指针异常。

public static void main(String[] args) throws Exception {
        OptionalTestApi(null);
}

 /**
     * 用于简化Java中对空值的判断处理，以防止出现各种空指针异常。
     * Optional实际上是对一个变量进行封装，它包含有一个属性value，实际上就是这个变量的值。
     */
    public static void OptionalTestApi(String value) throws Exception {
        Optional s = Optional.ofNullable(value);
        s.ifPresent(System.out::println);
        //当传入的对象为null时，orElse会展现设置值.不为null时展现原值
        System.out.println("orElse表达式：" + s.orElse("ss"));
        //变量为null时抛出异常
        System.out.println("orElseThrow()表达式:" + s.orElseThrow(() -> new Exception("变量为null!")));
    }

ofNullable是对参数进行null判断，isPresent是Value是否为空值的判断；

orElse是Value不为空则返回Value，否则返回传入的值；

orElseThrow是Value不为空则返回Value，否则抛出Supplier中生成的异常对象；

2.截一下Optional包含的方法图片

 3.Optional实践运行结果

1.Consumer用我的理解是接收参数操作的，有accept，andThen执行操作并传参数

 

public static void main(String[] args) throws Exception {
       ConsumerTestApi()
}

 /**
     * Consumer是一个函数式编程接口； 顾名思义，Consumer的意思就是消费，即针对某个东西我们来使用它，因此它包含有一个有输入而无输出的accept接口方法；
     * 除accept方法，它还包含有andThen这个方法；
     */
    public static void ConsumerTestApi() {
        //接口Consumer
        Consumer f = System.out::println;
        Consumer f2 = n -> System.out.println(n + "-f2");
        f.accept("testConsumer");
        //调一次f，再调一次f2  。执行完F后再执行F2的Accept方法
        f.andThen(f2).accept("testConsumer");
        //连续执行F的Accept方法
        f.andThen(f).andThen(f).andThen(f2).accept("test2");
    }

 2.说明都在代码里，下面来截一下运行结果

1.function也和Consumer差不多，函数编程，而函数经常是有输入输出的，因此它含有一个apply方法，包含一个输入与一个输出，apply方法外，它还有compose与andThen及indentity三个方法，其使用见下述示例；

public static void main(String[] args) throws Exception {
        functionTestApi()
}

/**
     * Function也是一个函数式编程接口；它代表的含义是“函数”，
     * 而函数经常是有输入输出的，因此它含有一个apply方法，包含一个输入与一个输出；
     * 除apply方法外，它还有compose与andThen及indentity三个方法，其使用见下述示例；
     */
    public static void functionTestApi() {
        //s就相当于参数, ->相当于方法体里的操作
        Function f = s -> s++;
        Function g = s -> s * 2;
        //对变量进行操作，执行f和g的操作
        System.out.println("f的操作:" + f.apply(2));
        System.out.println("g的操作:" + g.apply(2));
        /**
         * 下面表示在执行F时，先执行G，并且执行F时使用G的输出当作输入。
         * 相当于以下代码：
         * Integer a = g.apply(1);
         * System.out.println(f.apply(a));
         */
        System.out.println(f.compose(g).apply(2));
        /**
         * 表示执行F的Apply后使用其返回的值当作输入再执行G的Apply；
         * 相当于以下代码
         * Integer a = f.apply(1);
         * System.out.println(g.apply(a));
         */
        System.out.println(f.andThen(g).apply(5));

        /**
         * identity方法会返回一个不进行任何处理的Function，即输出与输入值相等；
         */
        System.out.println(Function.identity().apply(1));
    }

2.具体的介绍都在代码里介绍，那么运行一下

 

 1.Predicate为函数式接口，predicate的中文意思是“断定”，即判断的意思，判断某个东西是否满足某种条件，因此它包含test方法，根据输入值来做逻辑判断，其结果为True或者False。

public static void main(String[] args) throws Exception {
       predicateTestApi();
}

 

/**
     * Predicate为函数式接口，predicate的中文意思是“断定”，
     * 即判断的意思，判断某个东西是否满足某种条件；
     * 因此它包含test方法，根据输入值来做逻辑判断，其结果为True或者False。
     */
    public static void predicateTestApi() {
        Predicate p = o -> o.equals("predicate");
        Predicate p1 = o -> o.toString().contains("p");
        /**
         * negate: 用于对原来的Predicate做取反处理；
         * 如当调用p.test("test")为True时，调用p.negate().test("test")就会是False；
         */
        System.out.println(p.test("predicate"));//true
        System.out.println(p.negate().test("predicate"));//false
        /**
         * and: 针对同一输入值，多个Predicate均返回True时返回True，否则返回False；
         */
        System.out.println(p.and(p1).test("predicate"));

        /**
         * or: 针对同一输入值，多个Predicate只要有一个返回True则返回True，否则返回False
         */
        System.out.println(p.or(p1).test("re"));
    }

2.具体的介绍在代码里有，运行结果如下

怎么样，函数式编程接口还是可以的把，即方便还能无形感觉你高大上的代码，下一篇章介绍一下对集合的使用