一、函数式接口
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：欢迎留言
网友评论