一、函数式接口

1.函数式接口本质上还是一个接口，但是它是一种特殊的接口：
其实就是通过闭包作为参数定义接口内方法的参数，以及方法体。
一个函数式的接口，必须使用@FunctionalInterface进行修饰。
函数式接口其实就是定义不同参数和返回值类型的闭包。

//(1)定义一个函数式接口 Function<T, R> -T作为输入，返回的R作为输出
@FunctionalInterface
interface TestFunction<T, R> {
    R test(T from);
}

// 使用该接口
 TestFunction<String,String> function = (x) -> {System.out.print(x);return "Function";};
 System.out.println(function.test("hello world"));

//(2) TestFunction<T>  T作为输入，返回的boolean值作为输出
@FunctionalInterface
interface TestFunction<T> {
    boolean test(T from);
}

// 使用该接口.
 TestFunction<String> function = (x) -> {System.out.print(x);return  true;};
 System.out.println(function.test("hello world"));

//(3) TestFunction<T>  没有任何输入，返回T
@FunctionalInterface
interface TestFunction<T> {
    T test();
}

// 使用该接口.
 TestFunction<String> function = () -> {return "Supplier";};
 System.out.println(function.test());

//(4) TestFunction<T, T>  两个T作为输入，返回一个T作为输出，对于“reduce”操作很有用
@FunctionalInterface
interface TestFunction<T, T> {
    T test(T from, T from);
}

// 使用该接口.
 TestFunction<String, String> function =(x, y) -> {System.out.print(x+" "+y);return "AddOperator";};
 System.out.println(function.test("hello ","world"));

二、闭包（Lambda表达式）

2.Lambda表达式 也称闭包。
其实和iOS oc 里面的block 和 swift中的 closure 一样，本质都一样，都是匿名函数。

// Arrays.asList 返回的数组不能add 和 remove
 Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );
// 等同于,只是隐藏了String类型
Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );

// 如果需要语句块执行多条语句则如下
Arrays.asList( "a", "b", "d" ).forEach( e -> {
    System.out.print( e );
    System.out.print( e );
} );

三、Streams使用

// 定义一Task 类
private static class Task {
     private  boolean status;
    Task( boolean status, Integer points ) {
            this.status = status;
            this.points = points;
        }

     public Status getStatus() {
            return status;
        }
     public Integer getPoints() {
            return points;
        }
}

// 使用
Collection< Task > tasks = Arrays.asList(
    new Task( true, 5 ),
    new Task( true, 13 ),
    new Task( false, 8 ) 
);
// 计算status=true总和，mapToInt操作基于每个task实例的Task::getPoints方法将task流转换成Integer集合；
最后，通过sum方法计算总和，得出最后的结果 ：18。
double totalPointsOfOpenTasks = tasks
    .stream()
    .filter( task -> task.getStatus() == Status.OPEN )
    .mapToInt( Task::getPoints )
    .sum();

// 计算所有数总和，并行处理（parallel）。
这里我们使用parallel方法并行处理所有的task，并使用reduce方法计算最终的结果。
double totalPoints = tasks
   .stream()
   .parallel()
   .map( task -> task.getPoints() ) // or map( Task::getPoints ) 
   .reduce( 0, Integer::sum );

//对于一个集合，经常需要根据某些条件对其中的元素分组。利用steam可以快速实现
< Status, List< Task > > map = tasks
    .stream()
    .collect( Collectors.groupingBy( Task::getStatus ) );
System.out.println( map );
控制台的输出如下：
{CLOSED=[[CLOSED, 8]], OPEN=[[OPEN, 5], [OPEN, 13]]}

// 流转换为其它数据结构
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

//reduce 的用
// 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); 
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); 
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤，字符串连接，concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F").
 filter(x -> x.compareTo("Z") > 0).
 reduce("", String::concat);

PS：欢迎留言