Java 8 新特性Stream流

1、Java 8 新特性Stream流

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

以上的流程转换为 Java 代码为：

List<Integer> transactionsIds = widgets.stream()
    .filter(b -> b.getColor() == RED)
    .sorted((x,y) -> x.getWeight() - y.getWeight())
    .mapToInt(Widget::getWeight).sum();

2、什么是 Stream？

Stream（流）是一个来自数据源的元素队列并支持聚合操作

元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
数据源 流的来源。可以是集合，数组，I/O channel，产生器generator 等。
聚合操作 类似SQL语句一样的操作，比如filter, map, reduce, find, match, sorted等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

Pipelining : 中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格（fluent style）。这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代 ：以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代，这叫做外部迭代。 Stream提供了内部迭代的方式，通过访问者模式(Visitor)实现。

3、生成流

在 Java 8 中, 集合接口有两个方法来生成流：

stream() − 为集合创建串行流。
parallelStream() − 为集合创建并行流。

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

4、forEach

Stream 提供了新的方法 'forEach' 来迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数：

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

5、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()); 
List<String> list = Arrays.asList("a,b,c", "1,2,3");//将每个元素转成一个新的且不带逗号的元素
Stream<String> s1 = list.stream().map(s -> s.replaceAll(",",""));
s1.forEach(System.out::println); // abc  123

6、filter

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

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

7、limit

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

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

8、skip(n)：

跳过n元素，配合limit(n)可实现分页

9、distinct ：

通过流中元素的 hashCode() 和 equals() 去除重复元素

10、sorted

sorted 方法用于对流进行排序。
sorted()：自然排序。
sorted(Comparator com)：定制排序，自定义Comparator排序器。

以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：

// 自然排序Random random = new Random();random.ints().limit(10).sorted().forEach(System.out::println); 
// 定制排序List<String> list = Arrays.asList("aa", "ff", "dd");
//String 类自身已实现Compareable接口
list.stream().sorted().forEach(System.out::println);// aa dd ff

Student s1 = new Student("aa", 10);
Student s2 = new Student("bb", 20);
Student s3 = new Student("aa", 30);
Student s4 = new Student("dd", 40);
List<Student> studentList = Arrays.asList(s1, s2, s3, s4);//自定义排序：先按姓名升序，姓名相同则按年龄升序
studentList.stream().sorted(
        (o1, o2) -> {
            if (o1.getName().equals(o2.getName())) {
                return o1.getAge() - o2.getAge();
            } else {
                return o1.getName().compareTo(o2.getName());
            }
        }
).forEach(System.out::println);// 当前类new一个Comparator，只在当前对象生效
List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);		// 自定义排序		
Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {			
              @Override			
              public int compare(Integer o1, Integer o2) {return o1.compareTo(o2);}		
              }
           );
System.out.println("自定义排序的最大值：" + max2.get());

11、并行（parallel）程序

parallelStream 是流并行处理程序的代替方法。

并行流就是把一个内容分成多个数据块，并用不同的线程分成多个数据块，并用不同的线程分别处理每个数据块的流。

以下实例我们使用 parallelStream 来输出空字符串的数量：

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

我们可以很容易的在顺序运行和并行直接切换。

12、Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。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);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(","));

System.out.println("合并字符串: " + mergedString); 

// collectors操作
Student s1 = new Student("aa", 10,1);
Student s2 = new Student("bb", 20,2);
Student s3 = new Student("cc", 10,3);
List<Student> list = Arrays.asList(s1, s2, s3); //装成list
List<Integer> ageList = list.stream().map(Student::getAge).collect(Collectors.toList()); // [10, 20, 10] //转成list
setSet<Integer> ageSet = list.stream().map(Student::getAge).collect(Collectors.toSet()); // [20, 10] //转成set
//转成map,注:key不能相同，否则报错
Map<String, Integer> studentMap = list
         .stream()
         .collect(Collectors.toMap(Student::getName, Student::getAge)); // {cc=10, bb=20, aa=10}
         
//字符串分隔符连接
String joinName = list.stream().map(Student::getName) .collect(Collectors.joining(",", "(", ")")); // (aa,bb,cc) //聚合操作

//1.学生总数Long count = list.stream().collect(Collectors.counting()); // 3

//2.最大年龄 (最小的minBy同理)Integer maxAge = list.stream()
                                  .map(Student::getAge)
                                  .collect(Collectors.maxBy(Integer::compare)).get(); // 20
                                  
//3.所有人的年龄Integer sumAge = list.stream().collect(Collectors.summingInt(Student::getAge)); // 40

//4.平均年龄Double averageAge = list.stream().collect(Collectors.averagingDouble(Student::getAge)); // 13.333333333333334 

//分组Map<Integer, List<Student>> ageMap = list.stream().collect(Collectors.groupingBy(Student::getAge));

//多重分组,先根据类型分再根据年龄分
Map<Integer, Map<Integer, List<Student>>> typeAgeMap=list
                                   .stream()
                                   .collect(Collectors.groupingBy(Student::getType,Collectors.groupingBy(Student::getAge)));

//分区//分成两部分，一部分大于10岁，一部分小于等于10岁
Map<Boolean, List<Student>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 10));

//规约
Integer allAge = list.stream().map(Student::getAge).collect(Collectors.reducing(Integer::sum)).get(); //40

13、统计

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

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = 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());

posted @ 2021-07-13 14:47 小小安琪拉阅读(116) 评论(0) 收藏举报

刷新页面返回顶部

小小安琪拉