JDK8-第三章：java8新加常用函数

新加的函数都很好理解，直接看代码跑一跑就能知道怎么用了

什么是函数式(Functional)接口

●只包含一个抽象 方法的接口，称为函数式接口。
●你可以通过Lambda表达式来创建该接口的对象。( 若Lambda表达式
抛出一个受检异常(即:非运行时异常)，那么该异常需要在目标接口的抽
象方法上进行声明)。
●我们可以在- 一个接口上使用@FunctionalInterface注解，这样做可以检
查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个
接口是一个函数式接口。
●在java.util.function包下定 义了Java 8的丰富的函数式接口

package com.changxiong.newFunction;

/**
 * @author changxiong
 * @create 2020-12-14-8:03 PM
 */
public class Emp {
    private String name;

    public Emp() {

    }

    public Emp(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

package com.changxiong.newFunction;

import java.util.function.Function;

/**
 * @author changxiong
 * @create 2020-12-14-7:58 PM
 *
 * Funtion接口，定义了一个apply的抽象方法，接收一个泛型T对象，并且返回泛型R对象
 */
public class FunctionDemo {
    public static void main(String[] args) {
        Function<String,Integer> f1=s->s.length();
        Integer sdfsdlkf = f1.apply("sdfsdlkf");
        System.out.println(sdfsdlkf);

        Function<Integer, Integer> f2 = x -> x * 2;
        System.out.println(f2.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
    }
}

consumer

package com.changxiong.newFunction;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 * @author changxiong
 * @create 2020-12-14-7:07 PM
 */
public class ConsumerDemo {
    public static void main(String[] args) {
        Consumer<String>  c1=s-> System.out.println(s);
        c1.accept("aaaaaa");



        System.out.println("===BiConsumer用法=======");

        BiConsumer<String,String> c2=(s1,s2)-> System.out.println(s1+s2);
        c2.accept("aaa","bbb");

        System.out.println();

        Map<String, String> map = new HashMap<>();
        map.put("a", "a");
        map.put("b", "b");
        map.put("c", "c");
        map.put("d", "d");
        map.forEach((k, v) -> {
            System.out.print(k +" ：");
            System.out.println(v);

        });

    }
}

predicate

package com.changxiong.newFunction;

import java.util.function.Predicate;

/**
 * @author changxiong
 * @create 2020-12-14-6:19 PM
 *
 *
 * predicate 断言的意思
 * 功能传入值做判断，返回Boolean值
 */
public class predicateDemo {
    public static void main(String[] args) {
        Predicate<Integer> predicateInt = x -> x > 10;
        Predicate<String> predicateStr = r -> r.length() > 10;
        System.out.println("第一个Predicate的测试，测试数值是否大于10，结果为：" + predicateInt.test(11));
        System.out.println("第二个Predicate的测试，测试字符串的长度是否大于10，结果为：" + predicateStr.test("test"));
        System.out.println("第一个Predicate的【negate方法】测试，测试数值是否大于10，结果为：" + predicateInt.negate().test(11));
        System.out.println("第二个Predicate的【negate方法】测试，测试字符串的长度是否大于10，结果为：" + predicateStr.negate().test("test"));
    }

}

Supplier

package com.changxiong.newFunction;

import java.util.function.Supplier;

/**
 * @author changxiong
 * @create 2020-12-14-9:18 PM
 */
public class SupplierTest {
    public static void main(String[] args) {
        Supplier<String> str = new Supplier<String>() {
            @Override
            public String get() {
                return new String("ssss");
            }
        };

        System.out.println(str.get());

        System.out.println("=============================");

        Supplier<String> s=()->new String("ssss");
        System.out.println(str.get());

        System.out.println("=============================");

        Supplier<String> s2=String :: new;
        System.out.println(s2.get());

    }
}

UnaryOperator

package com.changxiong.newFunction;

import java.util.function.UnaryOperator;

/**
 * @author changxiong
 * @create 2020-12-14-7:45 PM
 */
public class UnaryOperatorDemo {
    public static void main(String[] args) {
        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
    }
}

Optional

到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。
以前，为了解决空指针异常，Google公 司著名的Guava项目引入了Optional类，
Guava通过使用检查空值的方式来防u止代码污染，它鼓励程序员写更干净的代
码。受到Google Guava的启发，Optional类 已经成为Java 8类库的一部分。
●Optional类(ava. util.Optional)是-一个容器类，它可以保存类型T的值，代表。
这个值存在。或者仅仅保存null,表示这个值不存在。原来用null 表示-一个值不
存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。
●Optional类的Javadoc描述如下: 这是一个可以为nul的容器对象。如果值存在

则isPresent()方法会返回true,调用get()方法 会返回该对象。

package com.changxiong.newFunction;

/**
 * @author changxiong
 * @create 2020-12-16-6:59 PM
 */
public class Boy {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return super.toString();
    }
}

package com.changxiong.newFunction;

import org.junit.Test;

import java.util.Optional;

/**
 * @author changxiong
 * @create 2020-12-16-6:51 PM
 */
public class OperatorTest {

    @Test
    public void test1() {
      //optional.of(T t) 创建一个实列， t必须为空
        Girl girl = new Girl();
        girl=null;
        Optional<Girl> girl1 = Optional.of(girl);
        System.out.println(girl1);
    }

    @Test
    public void test2() {
      //optional.of(T t) 创建一个实列， t必须为空
        Girl girl = new Girl();
        girl=null;
        Optional<Girl> girl1 = Optional.ofNullable(girl);
        System.out.println(girl1);
    }

    @Test
    public void test3() {
      //optional.of(T t) 创建一个实列， t必须为空
        Girl girl = new Girl();
        girl=null;
        Optional<Girl> girl1 = Optional.ofNullable(girl);
        System.out.println(girl1);

        Girl mylove = girl1.orElse(new Girl("欧阳娜娜"));
        System.out.println(mylove);
        
    }


}