学习笔记5:java 1.8 Predicate,Function,Supplier,Consumer,Comparator,Optional,Stream接口的使用

Predicate:
简单上一段代码:

            Predicate<String> predicate = (s) -> s.length() > 0;
            predicate.test("test java 1.8");              // true
            predicate.negate().test("test java 1.8");     // false
            Predicate<Boolean> nonNull = Objects::nonNull;
            Predicate<Boolean> isNull = Objects::isNull;
            Predicate<String> isEmpty = String::isEmpty;
            Predicate<String> isNotEmpty = isEmpty.negate();

简单说
Predicate 接口只是用来做 判断 的,提前写好判断的条件,然后传对象到test()方法里面,进行判断是否符合判断条件.
Predicate 只有一个 非defult 方法, test() ,返回值只有 boolean 类型,符合条件就是true,不符合就是 false .
个人认为更像是用来 判空 的.

Function :
简单上一段代码:

           //Function <参数类型,返回值类型>
            Function<String, Integer> toInteger = Integer::parseInt;
            //addThen(参数类型::需要调用的方法)
            toInteger.andThen(String::valueOf);
            Integer apply = toInteger.apply("test java 1.8 function");

简单说
Function 接口就是将需要调用的 参数 的 调用步骤 ,提前写好了,然后 返回值 也指定好了,就等着 一步步执行 了 , 非常简单的一个使用步骤.
Function 只有一个 非defult 方法, apply() ,返回值是 第二个泛型 的类型, apply 之后就会返回 值 .个人认为,他的价值,更像是充当一个 方法 的使用 .

Supplier:
简单上一段代码:

            Supplier<String> strSupplier = String::new;
            String str = strSupplier.get();

简单说:
这个是真简单,就是 new .Supplier 接口就相当于手动new一个对象的实例出来.然后 get() 出来.
Supplier 与 直接new对象 的区别是: Supplier 不接收任何参数,不能 new 接口 与 抽象类 .

Consumer:
简单上一段代码:

            Consumer<String> greeter = (s) -> System.out.println("String lenght = " + s.length());
            greeter.accept(new String("test java 1.8 consumer"));

简单说:
Consumer 接口也是真的非常简单,就是 提前调用对象的方法 ,然后在 accept 里将对象传递进去,与 Function 的区别,在下认为是 Consumer 没有返回值,而 Function 有 返回值.

Comparator:
简单上一段代码:

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);  
Person p1 = new Person("John", "Doe");  
Person p2 = new Person("Alice", "Wonderland");  
comparator.compare(p1, p2);             // > 0  
comparator.reversed().compare(p1, p2);  // < 0  

简单说:
Comparator 接口就是用来做 比较 的.在 构造函数 中,进行编写 比较条件 ,然后在 compare 方法中,传递对象进行进去比较,返回比较的结果 boolean .

Optional:
简单上一段代码:

            Optional<String> optional = Optional.of("test java 1.8 optional");
            optional.isPresent();           // true
            optional.get();                 // "test java 1.8 optional"
            optional.orElse("test java 1.8 optional");    // "test java 1.8 optional"
            optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "t"

简单说:
Optional 就是一个容器 ,他的价值,在于他装得东西.要不是null,要不是非null.
获取 Optional 对象的实例,需要调用他的静态方法 of() ,将对象传进去.