java-Stream流式编程

介绍

​ Stream作为Java8的一大亮点，它与java.io包里的InputStream和OutputStream是完全不同的概念。它是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的聚合操作或者大批量数据操作。

​ Stream API借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。所以说，Java8中首次出现的 java.util.stream是一个函数式语言+多核时代综合影响的产物。

​ Stream有如下三个操作步骤：

​ 一、创建Stream：从一个数据源，如集合、数组中获取流。

​ 二、中间操作：一个操作的中间链，对数据源的数据进行操作。

​ 三、终止操作：一个终止操作，执行中间操作链，并产生结果。

当数据源中的数据上了流水线后，这个过程对数据进行的所有操作都称为“中间操作”。中间操作仍然会返回一个流对象，因此多个中间操作可以串连起来形成一个流水线。

​ 比如map (mapToInt, flatMap 等)、filter、distinct、sorted、peek、limit、skip、parallel、sequential、unordered。

​ 当所有的中间操作完成后，若要将数据从流水线上拿下来，则需要执行终止操作。终止操作将返回一个执行结果，这就是你想要的数据。比如：forEach、forEachOrdered、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst、findAny、iterator。

​ 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何处理！而在终止操作时一次性全部处理，称作“惰性求值”。

起始操作

public class StreamTestA {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,124,12,4,65,1);
         //获得流
        Stream<Integer> stream = list.stream();
        
        }
}

中间操作

中间操作必须赋值

public class StreamTestA {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,124,12,4,65,1);
        //获得流
        Stream<Integer> stream = list.stream();
        //中间操作
        stream = stream.distinct()
//                .sorted()  //默认正序
                .sorted((x,y)->Integer.compare(y, x)) //倒序输出
                .limit(4)
                .skip(2) //跳过前几个
                .map(v->v*5)  //操作每个数
                .filter(v->v>=50); //筛选


    }
}

终止操作

终止操作只能有一条语句 否则会报java.lang.IllegalStateException: stream has already been operated upon or closed

public class StreamTestA {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,124,12,4,65,1);
        //获得流
        Stream<Integer> stream = list.stream();
        //中间操作
        stream = stream.distinct()
//                .sorted()  //默认正序
               .sorted((x,y)->Integer.compare(y, x)) //倒序输出
                .limit(4)
                .skip(2) //跳过前几个
                .map(v->v*5)  //操作每个数
                .filter(v->v>=50); //筛选

        //终止操作
//        System.out.println(stream.count());
        stream.forEach(System.out::println);

    }
}

创建方式

public class TestStream2 {
  public static void main(String[] args) {
    //创建Stream方式1
    List<Integer > list = new ArrayList<>();
    Collections.addAll(list,34,56,89,65,87,80,87,95,100,34,45);
    Stream stream = list.stream();
    stream.forEach(System.out::println);
    
    //创建Stream方式3:of()
    System.out.println("----------------");
    Stream stream3 = Stream.of(34,56,89,65,87,80,87,95,100,34,45);
    stream3.forEach(System.out::println);
    
    //创建Stream方式4
    int [] arr = {34,56,89,65,87,80,87,95,100,34,45};
    IntStream stream4 = Arrays.stream(arr);
    stream4.forEach(System.out::println);
    
    //创建Stream方式5
    Stream stream5 = Stream.generate(()->Math.random());
    stream5.forEach(System.out::println);
    
    //创建Stream方式6
    Stream stream6 = Stream.iterate(6,(i)->2+i);
    Stream stream6 = stream6.limit(5).forEach(System.out::println);
  }
}

并行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与串行流之间进行切换 。 Fork/Join 框架就是并行流 具体实现： 将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个一个小任务的运算结果进行 join 汇总

创建并行流

public static void main(String[] args) throws ExecutionException, InterruptedException {
  List<Integer > list = new ArrayList<>();
  Collections.addAll(list,34,56,89,65,87,80,87,95,100,34,45);
  //创建Stream方：并行流，底层采用ForkJoin框架，结果并不按照集合原有顺序输出
  Stream stream2 = list.parallelStream();//
  stream2.forEach((x)->System.out.println(x+"---"+Thread.currentThread().getName()));
}