jdk8Stream流实例demo

demo实例

 /***
 
  * @description
  * @author z
  * @date: 2021/4/21
  * @version: v1.0
     */
 
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import org.junit.Before;
 import org.junit.Test;
 
 
 import java.util.*;
 import java.util.function.Function;
 import java.util.function.ToIntFunction;
 import java.util.function.ToLongFunction;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 
 
 
 /***
  *
 
  * Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。
  * 原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；
  * 高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。
  * Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。
  * 而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。
  * 顾名思义，当使用串行方式去遍历时，每个 item 读完后再读下一个 item。
  * 而使用并行去遍历时，数据会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。
  * Stream 的并行操作依赖于 Java7 中引入的 Fork/Join 框架（JSR166y）来拆分任务和加速处理过程。
     */
 
 
 
 
 public class TestSteam
 {
    public List<Map<String, Object>> li = Lists.newArrayList();
    public Stream<List<Integer>> inputStream = null;
 
 
    /**
     * 获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，
     * 每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道
     * 一般的，数据源都是集合或者数组。
     * 对steam的使用就是实现一个filter-map-reduce的过程。并产生一个最终结果。
     * 流的操作类型分为两种：
     * Intermediate(中间操作)：一个流可以后面跟随零个或多个 intermediate 操作。
     * 其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。
     * 这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
     * map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
     * map。如果你熟悉 scala 这类函数式语言，对这个方法应该很了解，它的作用就是把 input Stream 的每一个元素，映射成 output Stream 的另外一个元素.
     * flatMap 一对多操作。
     * filter 对原始Stream进行过滤，通过测试的元素则生成新的steam。
     * <p>
     * Terminal（终端操作）：一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。
     * 所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个 side effect。
     * forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
     * forEach 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。
     * forEach 不能修改自己包含的本地变量值，也不能用 break/return 之类的关键字提前结束循环。
     * reduce
     * 这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。
     * 从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。
     * limit/skip
     * limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素（它是由一个叫 subStream 的方法改名而来）。
     * Short-circuiting：
     * 用以指：
     * 对于一个 intermediate 操作，如果它接受的是一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream。
     * 对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果
     * anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit
     * 这是一个 termimal 兼 short-circuiting 操作，它总是返回 Stream 的第一个元素，或者空。
     */
 
 
    @Test
    public void doChange()
    {
       int a = 65;
       char b = 'z';
       String text = "zhao";
       // Java 8
       // 为指定的值创建一个Optional，如果指定的值为null，则返回一个空的Optional。
       Optional<String> text1 = Optional.ofNullable(null);
       // 如果Optional实例有值则为其调用consumer，否则不做处理
 //       text1.ifPresent(System.out::println);
       text1.ifPresent(s -> System.out.println("hello " + s));
       // 如果值存在返回true，否则返回false。
       System.out.println(text1.isPresent());
       // 如果有值则将其返回，否则返回指定的其它值。
       System.out.println(text1.orElse("no value"));
       // jkd8以前
       if (text != null)
      {
          System.out.println("text:" + text);
      }
    }
 
 
 
 
    @Before
    public void doBefore()
    {
       for (int i = 0; i < 15; i++)
      {
          Random random = new Random();
          Map<String, Object> item = Maps.newHashMap();
          int i1 = random.nextInt(57) + 65;
          item.put("age", i1);
          item.put("name", (char) i1 + "" + (char) (i1) + 'z');
          li.add(item);
      }
    }
 
 
 
 
    @Before
    public void doBefore2()
    {
       inputStream = Stream.of(
             Arrays.asList(1),
             Arrays.asList(4, 5, 6),
             Arrays.asList(2, 3)
      );
    }
 
 
 
 
    @Test
    public void testReduce()
    {
       String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
       System.out.println(concat);
       // 求最小值，minValue = -3.0
       double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
       System.out.println(minValue);
       // 求和，sumValue = 10, 有起始值
       int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
       System.out.println(sumValue);
       // 求和，sumValue = 10, 无起始值
       sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
       System.out.println(sumValue);
       // 过滤，字符串连接，concat = "ace"
       concat = Stream.of("a", "B", "c", "D", "e", "F").
             filter(x -> x.compareTo("Z") > 0).
             reduce("", String::concat);
       System.out.println(concat);
    }
 
 
 
 
    /**
     * filter 对原始Stream进行过滤，通过测试的元素则生成新的steam。
     */
    @Test
    public void testFilter()
    {
       Object[] filter = li.stream().filter(stringObjectMap ->
      {
          String name = (String) stringObjectMap.get("name");
          if (name.contains("a"))
          {
             return true;
          }
          return false;
      }).toArray();
       System.out.println(Lists.newArrayList(filter));
 
 
 
 
    }
 
 
 
 
    @Test
    public void testMap1()
    {
       System.out.println(li);
       List<Object> rlt = li.stream().map(item ->
      {
          Object name = item.get("name");
          return name;
      }).collect(Collectors.toList());
 
 
       Optional<Object> first = rlt.stream().findFirst();
       System.out.println(rlt);
       System.out.println(first.isPresent());
 
 
    }
 
 
 
 
    /**
     * limit 返回 Stream 的前面 n 个元素；
     * skip 则是扔掉前 n 个元素（它是由一个叫 subStream 的方法改名而来）。
     */
    @Test
    public void testMap2()
    {
       System.out.println(li);
 
 
 
 
       List<Object> list = li.stream().map(item ->
      {
          Object name = item.get("name");
          return name;
      }).limit(10).skip(2).collect(Collectors.toList());
       System.out.println(list);
 
    }
 
 
 
 
    /**
     * map会将每一条输入映射为一个新对象,
     * flatMap包含两个操作：会将每一个输入对象输入映射为一个新集合，然后把这些新集合连成一个大集合。
     */
    @Test
    public void testFlatMap()
    {
 
 
       List<List<String>> namesNested = Arrays.asList(
             Arrays.asList("Jeff", "Bezos"),
             Arrays.asList("Bill", "Gates"),
             Arrays.asList("Mark", "Zuckerberg"));
 
 
       List<String> namesFlatStream = namesNested.stream()
 
 //         .flatMap(Collection::stream)
            .flatMap((Function<List<String>, Stream<String>>) strings -> strings.stream())
            .collect(Collectors.toList());
       System.out.println(namesFlatStream);
    }
 
 
    @Test
    public void testFlatMap2()
    {
 
 
       List<List<String>> namesNested = Arrays.asList(
             Arrays.asList("Jeff", "Bezos"),
             Arrays.asList("Bill", "Gates"),
             Arrays.asList("Mark", "Zuckerberg"));
 
 
       IntStream intStream = namesNested.stream()
            .flatMapToInt(strings ->
                   strings.stream().mapToInt(value -> value.length())
            );
       System.out.println(intStream.peek(System.out::println).sum());
 
    }
 
 
    /**
     * 某属性分组
     */
    @Test
    public void testGroupBy(){
       Map<Object, List<Map<String, Object>>> listMap = li.stream().collect(Collectors.groupingBy(stringObjectMap ->
      {
          Object age = stringObjectMap.get("age");
          return age;
      }));
       System.out.println(listMap);
    }
 
 
    /**
     * 分组求和,个数求和
     */
    @Test
    public void testGroupByAndSum(){
       System.out.println(li);
       Map<String, Long> name = li.stream().collect(Collectors.groupingBy(stringObjectMap -> stringObjectMap.get("name").toString(), Collectors.counting()));
       System.out.println(name);
 
 
    }
 
 
    /**
     * 分组求和,某属性求和
     */
    @Test
    public void testGroupByAndSum2(){
       System.out.println(li);
       Map<String, Long> sums = li.stream().collect(Collectors.groupingBy(stringObjectMap ->stringObjectMap.get("name").toString(),Collectors.summingLong(new ToLongFunction<Map<String, Object>>()
      {
          @Override
          public long applyAsLong(Map<String, Object> value)
          {
             String age = value.get("age").toString();
             return Long.parseLong(age);
          }
      })));
       System.out.println(sums);
    }
 
 
 }

说明

stream流在使用过程中的三个阶段

1. 生成并构造一个流 (List.stream() 等方法)
2. 在流的处理过程中添加、绑定惰性求值流程 (map、filter、limit 等方法)
3. 对流使用强制求值函数，生成最终结果 (max、collect、forEach等方法)

创建流： 调用集合的 stream() 方法或者 parallelStream() 方法创建流。 Stream 类的静态 of() 方法创建流。

 
 List< String> createStream = new ArrayList< String>();`
 // 顺序流
 `Stream< String> stream = createStream.stream();`
 // 并行流
 Stream< String> parallelStream = createStream.parallelStream();
 // of()方法创建
 Stream< String> stringStream = Stream.of(
        createStream.toArray(new String[createStream.size()]));

终端操作和中间操作

终端操作会消费 Stream 流，并且会产生一个结果，比如 iterator() 和 spliterator()。如果一个 Stream 流被消费过了，那它就不能被重用的。 中间操作会产生另一个流。需要注意的是中间操作不是立即发生的。而是当在中间操作创建的新流上执行完终端操作后，中间操作指定的操作才会发生。流的中间操作还分无状态操作和有状态操作两种。

在无状态操作中，在处理流中的元素时，会对当前的元素进行单独处理。比如，过滤操作，因为每个元素都是被单独进行处理的，所以它和流中的其它元素无关。 在有状态操作中，某个元素的处理可能依赖于其他元素。比如查找最小值，最大值，和排序，因为他们都依赖于其他的元素。