// ***java8 函数引用 -> 一种利用现有函数简单推理为函数表达式即简化的函数表达式（省去了参数，，-> 符号，只有更简化函数表达式体），[从而生成对应接口实现类默认的抽象方法体]。***// 函数表达式可以推理成java的匿名类，那么现有的函数就可以推理成函数表达式。只要现有的函数符合要生成的方法的签名即可（入参，返回值，函数名无关紧要）// 参数和返回值有编译器从上下文获得。从而省去了参数。只提供方法名就可以。
// 所以（arg) -> {} 函数表达式，可以简化为利用现有的函数引用：<class or instance name>::<methodName>。
package com.github.jdk8.ebook.java8_recipes2nd_edition;import java.util.Arrays;import java.util.Comparator;import java.util.List;import java.util.function.BiConsumer;import java.util.function.BiFunction;import java.util.function.BiPredicate;import java.util.function.BinaryOperator;import java.util.function.BooleanSupplier;import java.util.function.Consumer;import java.util.function.Function;import java.util.stream.Collectors;import java.util.stream.Stream;/** * * @author doctor * * @time 2015年2月4日 上午8:46:47 */public class Chapter6Code {public static void main(String[] args) {HelloType helloType = (arg) -> (System.out.println("hello " + arg));helloType.hello("doctor");Function<String, String> function = (value) -> "hello " + value;System.out.println(function.apply("doctor"));BiConsumer<String, String> biConsumer = (a, b) -> System.out.println(String.join(",", a, b));biConsumer.accept("BiConsumer hello", "doctor");BiFunction<String, String, String> biFunction = (a, b) -> String.join(",", a, b);System.out.println(biFunction.apply("BiFunction", "hello"));// BinaryOperator 是一种特殊的BiFunction，参数是相同类型（入参，返回类型）BinaryOperator<String> binaryOperator = (a, b) -> String.join(",", a, b);System.out.println(binaryOperator.apply("binaryOperator ", "hello"));BiPredicate<String, String> biPredicate = (a, b) -> a.equals(b);System.out.println("BiPredicate:" + biPredicate.test("ab", "cd"));BooleanSupplier booleanSupplier = () -> true;System.out.println("BooleanSupplier:" + booleanSupplier.getAsBoolean());Consumer<String> consumer = (a) -> System.out.println(a);consumer.accept("Consumer:" + "hello");List<String> collect = Stream.of("c", "dca", "cddd", "abccss", "ba", "aab").parallel().sorted(Comparator.comparing(String::length)).collect(Collectors.toList());collect.forEach(System.out::println);// ***java8 函数引用 -> 一种利用现有函数简单推理为函数表达式即简化的函数表达式（省去了参数，-> 符号，只有更简化函数表达式体），[从而生成对应接口实现类默认的抽象方法体]。***// 函数表达式可以推理成java的匿名类，那么现有的函数就可以推理成函数表达式。只要现有的函数符合要生成的方法的签名即可（入参，返回值，函数名无关紧要）// 参数和返回值有编译器从上下文获得。从而省去了参数。只提供方法名就可以。// 所以（arg) -> {} 函数表达式，可以简化为利用现有的函数引用：<class or instance name>::<methodName>。// A method reference is a// simplified form of a lambda expression, which specifies the class name or instance name, followed by the method to// be called in the following format:// <class or instance name>::<methodName>// The double colon (::) operator specifies a method reference. Since a method reference is a simplified lambda// method, it must implement a functional interface, and the abstract method within the interface must have the same// argument list and return type as the method being referenced. Any arguments are subsequently derived from the// context of the method reference. For instance, consider the same scenario as the solution, whereby you wanted to sort// an array of Player objects by calling upon the Player.compareByGoal() method to perform goal comparisons.// The following code could be written to enable this functionality via a lambda expression:Integer[] integers = { 12, 45, 1, 66, 33, 22 };System.out.println("lambda expression排序前：");Arrays.stream(integers).forEach(System.out::println);Arrays.sort(integers, (a, b) -> Integer.compare(a, b)); // 用lambda expression 生成匿名类 Comparator , 实现compare(T o1, T o2) 方法System.out.println("lambda expression 排序后：");Arrays.stream(integers).forEach(System.out::println);Integer[] integers2 = { 12, 45, 1, 66, 33, 22 };System.out.println("函数引用排序前：");Arrays.stream(integers2).forEach(System.out::println);Arrays.sort(integers2, Integer::compare); // 用函数引用生成匿名类，System.out.println("函数引用排序后：");Arrays.stream(integers2).forEach(System.out::println);}@FunctionalInterfacepublic interface HelloType {void hello(String message);}}
流转的时光，都成为命途中美丽的点缀，
