jdk8出来日子不短了，jdk11都出来了，不过用的最多的不过是1.5罢了。

今年终于鼓起勇气认真对待它，在18年记录下学习stream，画上一个圆。

Java8中有两大最为重要的改变。第一个是Lambda 表达式；另外一个则是Stream API(java.util.stream.*)。

说说stream吧。前提得有lambda的基础。

Stream 是Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL 执行的数据库查询。也可以使用Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

对stream的操作分为三类。

  1. 创建stream
  2. 中间操作(intermediate operations)
  3. 结束操作(terminal operations):

流程如下图

创建stream

虽然大部分情况下stream是容器调用Collection.stream()方法得到的，但stream和collections有以下不同：

  • 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
  • 为函数式编程而生。对stream的任何修改都不会修改背后的数据源，比如对stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新stream。
  • 惰式执行。stream上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。
  • 可消费性。stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。
Stream API是Java 8中加入的一套新的API，主要用于处理集合操作，不过它的处理方式与传统的方式不同，

称为“数据流处理”。流（Stream）类似于关系数据库的查询操作，是一种声明式操作。比如要从数据库中获取所有id大于1(filter)的用户的名称(map)，

并按照用户的score进行排序(sorted)，如果在sql中就会很容易完成，但是在java程序中，在jdk8以前可能要使用很多的if条件，但是在jdk8的stream

流中，我们可以这样 
  1. @Test
  2.     public void test5() {
  3.         List<String> collect = list.stream()
  4.                 .filter(p -> p.getId() > 1)
  5.                 .sorted(Comparator.comparing(Star::getScore))
  6.                 .map(Star::getName)
  7.                 .collect((Collectors.toList()));
  8.         System.out.println(collect);
  9.     }

 就是这么的容易。

 
 
 
 
jdk双冒号
还是比较绕的，看代码就明白了。详细借鉴
  1. package com.test;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.function.Consumer;
  7. import org.junit.Test;
  9. public class DoubleColonTest {
  10.     
  11.     public static void myPrint(String str) {
  12.         System.out.println("print value : " + str);
  13.     }
  14.     
  15.     /**
  16.      * 不使用双冒号
  17.      */
  18.     @Test
  19.     public void test1() {
  20.         List<String> list = Arrays.asList("刘德华","黎明","张学友","郭富城");
  21.         list.forEach(p -> myPrint(p));
  22.     }
  23.     
  24.     /**
  25.      * 使用双冒号
  26.      */
  27.     @Test
  28.     public void test2() {
  29.         List<String> list = Arrays.asList("刘德华","黎明","张学友","郭富城");
  30.         list.forEach(DoubleColonTest::myPrint);
  31.     }
  32.     
  33.     /**
  34.      * 类似于双冒号
  35.      */
  36.     @Test
  37.     public void test3() {
  38.         List<String> list = Arrays.asList("刘德华","黎明","张学友","郭富城");
  39.         Consumer<String> methodParam = DoubleColonTest::myPrint;
  40.         list.forEach(methodParam);
  41.     }
  42.     
  43.     /**
  44.      * 类似于双冒号
  45.      */
  46.     @Test
  47.     public void test4() {
  48.         List<String> list = Arrays.asList("刘德华","黎明","张学友","郭富城");
  49.         Consumer<String> methodParam = DoubleColonTest::myPrint;
  50.         list.forEach(p -> methodParam.accept(p));
  51.     }
  52.     
  53. }

 

 

完整代码实例

  1. package com.test;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.Comparator;
  6. import java.util.Iterator;
  7. import java.util.List;
  8. import java.util.stream.Collectors;
  9. import java.util.stream.Stream;
  11. import org.junit.Before;
  12. import org.junit.Test;
  14. public class TestStream {
  16.     List<Star> list = null;
  18.     @Before
  19.     public void before() {
  20.         list = new ArrayList<Star>() {
  21.             {
  22.                 add(new Star(1, "张学友", 11.3));
  23.                 add(new Star(3, "刘德华", 4.3));
  24.                 add(new Star(2, "黎明", 13.3));
  25.                 add(new Star(5, "郭富城", 22.3));
  26.                 add(new Star(4, "范冰冰", 2.3));
  27.             }
  28.         };
  29.     }
  31.     /**
  32.      * 遍历方式
  33.      */
  34.     @Test
  35.     public void test1() {
  36.         System.out.println("第一种---------");
  37.         for (Star Star : list) {
  38.             System.out.println(Star);
  39.         }
  41.         System.out.println("第二种---------");
  42.         list.forEach(p -> System.out.println(p));
  44.         System.out.println("第三种---------");
  45.         list.forEach(System.out::println);
  47.         System.out.println("第四种---------");
  48.         Iterator<Star> iterator = list.iterator();
  49.         while (iterator.hasNext()) {
  50.             System.out.println(iterator.next());
  51.         }
  53.         System.out.println("第五种---------");
  54.         for (int i = 0; i < list.size(); i++) {
  55.             System.out.println(list.get(i));
  56.         }
  58.         System.out.println("第六种---------");
  59.         for (Iterator<Star> it = list.iterator(); it.hasNext();) {
  60.             System.out.println(it.next());
  61.         }
  63.         System.out.println("第七种---------");
  64.         for (int i = 0; i < list.size();) {
  65.             System.out.println(list.get(i));
  66.             i++;
  67.         }
  69.     }
  71.     /**
  72.      * 普通排序
  73.      */
  74.     @Test
  75.     public void test2() {
  76.         Collections.sort(list, new Comparator<Star>() {
  77.             @Override
  78.             public int compare(Star o1, Star o2) {
  79.                 return o1.getScore().compareTo(o2.getScore());
  80.             }
  81.         });
  82.         list.forEach(p -> System.out.println(p));
  83.     }
  85.     /**
  86.      * lambda排序
  87.      */
  88.     @Test
  89.     public void test3() {
  90.         Collections.sort(list, (p1, p2) -> p1.getScore().compareTo(p2.getScore()));
  91.         list.forEach(p -> System.out.println(p));
  92.     }
  94.     /**
  95.      * streame排序
  96.      */
  97.     @Test
  98.     public void test4() {
  99.         Stream<Star> stream = list.stream().sorted(Comparator.comparing(Star::getScore));// .forEach(p ->
  100.         stream.forEach(p -> System.out.println(p));
  101.         // list.forEach(p -> System.out.println(p));
  102.     }
  104.     /**
  105.      * 进行过滤操作
  106.      */
  107.     @Test
  108.     public void test5() {
  109.         List<String> collect = list.stream()
  110.                 .filter(p -> p.getId() > 1)
  111.                 .sorted(Comparator.comparing(p -> p.getScore()))
  112. //                .sorted(Comparator.comparing(Star::getScore))
  113.                 .map(Star::getName)
  114.                 .collect((Collectors.toList()));
  115.         System.out.println(collect);
  116.     }
  118. }
  120. class Star {
  121.     private Integer id;
  122.     private String name;
  123.     private Double score;
  125.     public Double getScore() {
  126.         return score;
  127.     }
  129.     public void setScore(Double score) {
  130.         this.score = score;
  131.     }
  133.     public Integer getId() {
  134.         return id;
  135.     }
  137.     public void setId(Integer id) {
  138.         this.id = id;
  139.     }
  141.     public String getName() {
  142.         return name;
  143.     }
  145.     public void setName(String name) {
  146.         this.name = name;
  147.     }
  149.     public Star() {
  150.         super();
  151.     }
  153.     public Star(Integer id, String name, Double score) {
  154.         super();
  155.         this.id = id;
  156.         this.name = name;
  157.         this.score = score;
  158.     }
  160.     @Override
  161.     public String toString() {
  162.         return "Star [id=" + id + ", name=" + name + ", score=" + score + "]";
  163.     }
  165. }

 

OK，到位，入个门。。。

 
借鉴的地址
http://www.nowcode.cn/index.php/2017/02/27/326/
https://www.jianshu.com/p/ceb7bf515c03
 
 
 
 
 

 

版权声明：本文为c-h-y原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/c-h-y/p/10127884.html