Java8 - Lambda表达式和Stream流 - 《Java 学习笔记》

Stream
流的中间操作
流的终结操作

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
Lambda 表达式免去了使用匿名内部类的麻烦，并且给予Java简单但是强大的函数化的编程能力。
其实Lambda表达式的本质只是一个”语法糖”，由编译器推断并帮你转换包装为常规的代码，因此你可以使用更少的代码来实现同样的功能。
lambda表达式允许你通过表达式来代替功能接口。
lambda表达式就和方法一样，它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
Lambda表达式还增强了集合库。
Java SE 8添加了2个对集合数据进行批量操作的包：java.util.function 包以及java.util.stream 包。
流(stream)就如同迭代器(iterator)，但附加了许多额外的功能。
总的来说,lambda表达式和 stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
基本用法

// 1. 不需要参数,返回值为 5  
() -> 5  ;
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  ;
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  ;
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  ;
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s) ;

一、遍历list集合
程序员可以使用 for 语句 (“for 循环”)来遍历，也可以使用lambda表达式遍历，还可以使用forEach遍历。

String[] strs = {"Rafael Nadal", "Novak Djokovic","Juan Martin Del Potro"};
List<String> strList =  Arrays.asList(strs);  
// 以前的循环方式  
for (String str : strList) {  
     System.out.println(str);  s
}  
// 使用 lambda 表达式以及函数操作(functional operation)  
strList.forEach((str) -> System.out.println(str));  
// 在 Java 8 中使用双冒号操作符(double colon operator)  
strList.forEach(System.out::println);

二、代替匿名内部类

// 直接使用匿名内部类  
    button.addActionListener(new ActionListener(){
        @Override
        public void click(String name) {
            System.out.println("下载资源"+name);
        }
    });
// 使用 lambda表达式
button.addActionListener(name -> System.out.println("下载资源"+name));

还可以使用lambdas 来实现创建线程

// 使用匿名内部类  
new Thread(new Runnable() {  
    @Override  
    public void run() {  
        System.out.println("线程启动!");  
    }  
}).start();  
// 使用 lambda表达式
new Thread(() -> System.out.println("线程启动!")).start();

Stream

Stream（流）是一个来自数据源的元素队列并支持聚合操作。
元素是特定类型的对象，形成一个队列。
Java中的Stream并不会存储元素，而是按需计算。
数据源流的来源可以是集合、数组、I/O channel、产生器generator 等。
聚合操作类似SQL语句一样的操作，比如filter, map, reduce, find, match, sorted等。
和以前的Collection操作不同， Stream操作还有两个基础的特征：
1）Pipelining: 中间操作都会返回流对象本身。
这样多个操作可以串联成一个管道，如同流式风格（fluent style）。
这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。
2）内部迭代：以前对集合遍历都是通过Iterator或者For-Each的方式，显式的在集合外部进行迭代，这叫做外部迭代。
Stream提供了内部迭代的方式，通过访问者模式(Visitor)实现。
Java8 提供了四大核心函数式接口
Consumer消费型接口，Supplier供给型接口，Function函数型接口，Predicate断言型接口
使用Stream的基本步骤：
1）创建Stream；
2）转换Stream，每次转换原有Stream对象不改变，返回一个新的Stream对象（可以有多次转换）；
3）对Stream进行聚合（Reduce）操作，得到想要的结果。
如：list.stream().filter(s->s!=null).collect(Collectors.toList())
1）list.stream()负责创建一个Stream实例；
2）filter(s->s!=null)负责把一个Stream转换成另外一个Stream，经过filter方法以后，重新生成了一个过滤掉原list列表中不为null的Stream；
3）collect(Collectors.toList())把Stream的转换成需要的结果。
在 Java 8 中, 集合接口有两种流：
1）stream() − 为集合创建串行流。
2）parallelStream() − 为集合创建并行流。
parallelStream 是流并行处理程序的代替方法。
以下实例我们使用 parallelStream 来输出空字符串的数量：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); 
// 获取空字符串的数量
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

生成流
最常用的创建Stream有两种途径：
1）通过Stream接口的静态工厂方法（注意：Java8里接口可以带静态方法）；
i）of方法：有两个重载方法，一个只能接受一个泛型参数T t，一个接受可变长的泛型参数T… values

Stream<String> stringStream = Stream.of("taobao");
Stream<Integer> integerStream = Stream.of(1, 2, 3, 5);

ii）generator方法：生成一个无限长度的Stream，其元素的生成是通过给定的Supplier（这个接口可以看成一个对象的工厂，每次调用返回一个给定类型的对象）

Stream.generate(new Supplier<Double>() {
    @Override
    public Double get() {
        return Math.random();
    }
});
Stream.generate(() -> Math.random());
Stream.generate(Math::random);
//三条语句的作用都是一样的，只是使用了lambda表达式和方法引用的语法来简化代码。
//每条语句其实都是生成一个无限长度的Stream，其中值是随机的。
//这个无限长度Stream是懒加载，一般这种无限长度的Stream都会配合Stream的limit()方法来用。

iii）iterate方法：也是生成无限长度的Stream，和generator不同的是，其元素的生成是重复对给定的种子值(seed)调用用户指定函数来生成的。
其中包含的元素可以认为是：seed，f(seed),f(f(seed))无限循环

Stream.iterate(1, item -> item + 1).limit(10).forEach(System.out::println);
//这段代码就是先获取一个无限长度的正整数集合的Stream，然后取出前10个打印。千万记住使用limit方法，不然会无限打印下去。

2）通过Collection接口的默认方法stream()，把一个Collection对象转换成Stream
（默认方法：Default method，也是Java8中的一个新特性，就是接口中的一个带有实现的方法）

流的中间操作

map
map 方法用于映射每个元素到对应的结果。
以下代码片段使用 map 得到了元素平方数去重后的集合：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

filter
filter 方法用于通过设置的条件过滤出元素。
以下代码片段使用 filter 方法过滤出空字符串的个数：

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = strings.stream().filter(string -> string.isEmpty()).count();

limit
limit 方法用于获取指定数量的流。
以下代码片段使用 limit 方法打印出 10 条数据：

Randomrandom = new Random(); 
random.ints().limit(10).forEach(System.out::println);

sorted
sorted() 方法用于对流进行排序。
sorted(Comparator)将流元素按Comparator排序。
以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：

Randomrandom = new Random(); 
random.ints().limit(10).sorted().forEach(System.out::println);

skip(n)
skip(n)方法跳过前n个元素。

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
numbers.stream().skip(5).sorted().forEach(System.out::println);
//输出
//3
//5

流的终结操作

约简操作
1）max(Comparator)
2）min(Comparator)
3）count()
4）findFirst()
返回第一个元素
5）findAny()
返回任意元素
6）anyMatch(Predicate)
任意元素匹配时返回true
7）allMatch(Predicate)
所有元素匹配时返回true
8）noneMatch(Predicate)
没有元素匹配时返回true
收集操作
1）iterator()
2）forEach(fun)
Stream 提供了新的方法 ‘forEach’ 来迭代流中的每个数据。
以下代码片段使用 forEach 输出了10个随机数：

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

3）forEachOrdered(fun)
可以应用在并行流上以保持元素顺序
4）toArray()
5）toArray(T[] :: new)
返回正确的元素类型
6）collect(Collector)
7）collect(fun1, fun2, fun3)
fun1转换流元素；fun2为累积器，将fun1的转换结果累积起来；fun3为组合器，将并行处理过程中累积器的各个结果组合起来。
Collector收集器
看看有哪些收集器。
Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。
1）Collectors.toList()
2）Collectors.toSet()
3）Collectors.toCollection(集合的构造器引用)
4）Collectors.joining()、Collectors.joining(delimiter)、Collectors.joining(delimiter、prefix、suffix)
字符串元素连接
5）Collectors.summarizingInt/Long/Double(ToInt/Long/DoubleFunction)
产生Int/Long/DoubleSummaryStatistics对象，它有getCount、getSum、getMax、getMin方法。
注意在没有元素时，getMax和getMin返回Integer/Long/Double.MAX/MIN_VALUE
6）Collectors.toMap(fun1, fun2)/toConcurrentMap
两个fun用来产生键和值，若值为元素本身，则fun2为Function.identity()
7）Collectors.toMap(fun1, fun2, fun3)/toConcurrentMap
fun3用于解决键冲突，例如(oldValue, newValue) -> oldValue，有冲突时保留原值
8）Collectors.toMap(fun1, fun2, fun3, fun4)/toConcurrentMap
默认返回HashMap或ConcurrentHashMap，fun4可以指定返回的Map类型
如下Collectors 可用于返回列表或字符串：

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//返回集合
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered);
//筛选列表: [abc, bc, efg, abcd, jkl]
//joining方法是按照给定的模式来组合字符串，如果未规定，则得到的是合并的字符串 如abcbcefgabcdjkl
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);
//合并字符串: abc, bc, efg, abcd, jkl

统计
另外，一些产生统计结果的收集器也非常有用。
它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
IntSummaryStatisticsstats = numbers.stream().mapToInt((x) -> x).summaryStatistics(); 
System.out.println("列表中最大的数 : " + stats.getMax()); 
System.out.println("列表中最小的数 : " + stats.getMin()); 
System.out.println("所有数之和 : " + stats.getSum()); 
System.out.println("平均数 : " + stats.getAverage());