java 闭包 函数_Java8 新特性，闭包（Lambda表达式），和函数式接口

一、函数式接口

1.函数式接口本质上还是一个接口，但是它是一种特殊的接口：

其实就是通过闭包作为参数定义接口内方法的参数，以及方法体。

一个函数式的接口，必须使用@FunctionalInterface进行修饰。

函数式接口其实就是定义不同参数和返回值类型的闭包。

//(1)定义一个函数式接口 Function -T作为输入，返回的R作为输出

@FunctionalInterface

interface TestFunction {

R test(T from);

}

// 使用该接口

TestFunction function = (x) -> {System.out.print(x);return "Function";};

System.out.println(function.test("hello world"));

//(2) TestFunction T作为输入，返回的boolean值作为输出

@FunctionalInterface

interface TestFunction {

boolean test(T from);

}

// 使用该接口.

TestFunction function = (x) -> {System.out.print(x);return true;};

System.out.println(function.test("hello world"));

//(3) TestFunction 没有任何输入，返回T

@FunctionalInterface

interface TestFunction {

T test();

}

// 使用该接口.

TestFunction function = () -> {return "Supplier";};

System.out.println(function.test());

//(4) TestFunction 两个T作为输入，返回一个T作为输出，对于“reduce”操作很有用

@FunctionalInterface

interface TestFunction {

T test(T from, T from);

}

// 使用该接口.

TestFunction 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 list1 = stream.collect(Collectors.toList());

List 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：欢迎留言