Java8 新特性,闭包(Lambda表达式),和函数式接口

一、函数式接口

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

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容