stream流

stream概述

Java8是所有版本中热度最高的几个之一,其中引入了stream流，Optional等特性。

接口

接口	描述
BaseStream<T,S extends BaseStream<T,S>>	流的基本接口，流是支持顺序和并行聚合操作的元素序列。
Collector<T,A,R>	将输入元素累积到可变结果容器中的可变归约操作，可选择在处理完所有输入元素后将累积结果转换为最终表示。	---
DoubleStream	支持顺序和并行聚合操作的原始双值元素序列。
DoubleStream.Builder	一个可变构建器DoubleStream。
IntStream	支持顺序和并行聚合操作的原始整数值元素序列。
IntStream.Builder	可变构建器IntStream。
LongStream	支持顺序和并行聚合操作的原始长值元素序列。
LongStream.Builder	可变构建器LongStream。
Stream< T>	支持顺序和并行聚合操作的元素序列。
Stream.Builder< T>	可变构建器Stream。

特点

1、没有存储。流不是存储元素的数据结构；相反，它通过计算操作的管道传送来自数据结构、数组、生成器函数或 I/O 通道等源的元素。
2、功能性。对流的操作会产生结果，但不会修改其源。例如，过滤Stream 从集合中获得的 a 会生成一个Stream没有过滤元素的新元素，而不是从源集合中删除元素。
3、懒惰寻求。许多流操作，例如过滤、映射或重复删除，可以懒惰地实现，从而暴露优化机会。例如，“找到String具有三个连续元音的第一个”不需要检查所有输入字符串。流操作分为中间（Stream生产）操作和终端（价值或副作用生产）操作。中间操作总是懒惰的。
4、可能无界。虽然集合具有有限的大小，但流不需要。诸如limit(n)或 之 类的短路操作findFirst()可以允许在有限时间内完成对无限流的计算。
5、消耗品。流的元素在流的生命周期内仅被访问一次。与 一样Iterator，必须生成新的流以重新访问源的相同元素。

stream操作类型

方法

所有静态方法

静态方法

修饰符和类型	方法	说明
static < T>Stream.Builder< T>	builder()	返回 a 的构建器Stream。
static < T> Stream< T>	concat(Stream<? extends T> a, Stream<? extends T> b)	创建一个延迟连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
static < T> Stream< T>	empty()	返回一个空的序列Stream。
static < T> Stream< T>	generate(Supplier< T> s)	返回一个无限连续的无序流，其中每个元素都由提供的 生成Supplier。
static < T> Stream< T>	iterate(T seed, UnaryOperator< T> f)	返回一个无限连续有序Stream通过函数的迭代应用产生f为初始元素seed，产生Stream包括seed，f(seed)， f(f(seed))，等。
static < T> Stream< T>	of(T... values)	返回其元素为指定值的顺序有序流。
static < T> Stream< T>	of(T t)	返回一个Stream包含单个元素的序列。

实例方法

实例方法

修饰符和类型	方法	说明
boolean	allMatch(Predicate<? super T> predicate)	返回此流的所有元素是否与提供的谓词匹配。
boolean	anyMatch(Predicate<? super T> predicate)	返回此流的任何元素是否与提供的谓词匹配。
<R,A> R	collect(Collector<? super T,A,R> collector)	使用 对该流的元素执行可变归约操作 Collector。
< R> R	collect(Supplier< R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)	对此流的元素执行可变的归约操作。
long	count()	返回此流中元素的计数。
Stream< T>	distinct()	返回由该流的不同元素（根据 Object.equals(Object)）组成的流。
Stream< T>	filter(Predicate<? super T> predicate)	返回由与给定谓词匹配的此流的元素组成的流。
Optional< T>	findAny()	返回一个Optional描述流的某个元素的值，Optional如果流为空，则返回一个空值。
Optional< T>	findFirst()	返回一个Optional描述此流的第一个元素的值，Optional如果流为空，则返回一个空值。
< R> Stream< R>	flatMap(Function<? super T,? extends Stream<? extends R>> mapper)	返回一个流，该流由通过将提供的映射函数应用于每个元素而生成的映射流的内容替换此流的每个元素的结果组成。
DoubleStream	flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)	返回一个DoubleStream包含用映射流的内容替换此流的每个元素的结果，该映射流是通过将提供的映射函数应用于每个元素而产生的。
IntStream	flatMapToInt(Function<? super T,? extends IntStream> mapper)	返回一个IntStream包含用映射流的内容替换此流的每个元素的结果，该映射流是通过将提供的映射函数应用于每个元素而产生的。
LongStream	flatMapToLong(Function<? super T,? extends LongStream> mapper)	返回一个LongStream包含用映射流的内容替换此流的每个元素的结果，该映射流是通过将提供的映射函数应用于每个元素而产生的。
void	forEach(Consumer<? super T> action)	对此流的每个元素执行一个操作。
void	forEachOrdered(Consumer<? super T> action)	如果流具有定义的遇到顺序，则按流的遇到顺序对此流的每个元素执行操作。
Stream< T>	limit(long maxSize)	返回由该流的元素组成的流，被截断为maxSize长度不超过。
< R> Stream< R>	map(Function<? super T,? extends R> mapper)	返回由将给定函数应用于此流的元素的结果组成的流。
DoubleStream	mapToDouble(ToDoubleFunction<? super T> mapper)	返回DoubleStream由将给定函数应用于此流的元素的结果组成。
IntStream	mapToInt(ToIntFunction<? super T> mapper)	返回一个IntStream由将给定函数应用于此流的元素的结果组成。
LongStream	mapToLong(ToLongFunction<? super T> mapper)	返回LongStream由将给定函数应用于此流的元素的结果组成。
Optional< T>	max(Comparator<? super T> comparator)	根据提供的 返回此流的最大元素 Comparator。
Optional< T>	min(Comparator<? super T> comparator)	根据提供的 返回此流的最小元素 Comparator。
boolean	noneMatch(Predicate<? super T> predicate)	返回此流的元素是否与提供的谓词匹配。
Stream< T>	peek(Consumer<? super T> action)	返回一个由该流的元素组成的流，另外在每个元素上执行提供的操作，因为元素从结果流中被消耗。
Optional< T>	reduce(BinaryOperator accumulator)	使用关联累积函数对此流的元素 执行缩减，并返回描述缩减的值（如果有）。Optional
T	reduce(T identity, BinaryOperator accumulator)	使用提供的标识值和关联 累积函数对该流的元素 执行归约，并返回归约后的值。
< U> U	reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator combiner)	使用提供的标识、累积和组合函数对该流的元素执行归约。
Stream< T>	skip(long n)	丢弃流的第一个n元素后，返回由该流的其余元素组成的流。
Stream< T>	sorted()	返回由该流的元素组成的流，按自然顺序排序。
Stream< T>	sorted(Comparator<? super T> comparator)	返回由该流的元素组成的流，根据提供的 进行排序Comparator。
Object[]	toArray()	返回一个包含此流元素的数组。
< A> A[]	toArray(IntFunction<A[]> generator)	返回一个包含此流元素的数组，使用提供的generator函数分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。

抽象方法

抽象方法

修饰符和类型	方法	说明
boolean	allMatch(Predicate<? super T> predicate)	返回此流的所有元素是否与提供的谓词匹配。
boolean	anyMatch(Predicate<? super T> predicate)	返回此流的任何元素是否与提供的谓词匹配。
<R,A> R	collect(Collector<? super T,A,R> collector)	使用 对该流的元素执行可变归约操作 Collector。
< R> R	collect(Supplier< R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)	对此流的元素执行可变的归约操作。
long	count()	返回此流中元素的计数。
Stream< T>	distinct()	返回由该流的不同元素（根据 Object.equals(Object)）组成的流。
Stream< T>	filter(Predicate<? super T> predicate)	返回由与给定谓词匹配的此流的元素组成的流。
Optional< T>	findAny()	返回一个Optional描述流的某个元素的值，Optional如果流为空，则返回一个空值。
Optional< T>	findFirst()	返回一个Optional描述此流的第一个元素的值，Optional如果流为空，则返回一个空值。
< R> Stream< R>	flatMap(Function<? super T,? extends Stream<? extends R>> mapper)	返回一个流，该流由通过将提供的映射函数应用于每个元素而生成的映射流的内容替换此流的每个元素的结果组成。
DoubleStream	flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)	返回一个DoubleStream包含用映射流的内容替换此流的每个元素的结果，该映射流是通过将提供的映射函数应用于每个元素而产生的。
IntStream	flatMapToInt(Function<? super T,? extends IntStream> mapper)	返回一个IntStream包含用映射流的内容替换此流的每个元素的结果，该映射流是通过将提供的映射函数应用于每个元素而产生的。
LongStream	flatMapToLong(Function<? super T,? extends LongStream> mapper)	返回一个LongStream包含用映射流的内容替换此流的每个元素的结果，该映射流是通过将提供的映射函数应用于每个元素而产生的。
void	forEach(Consumer<? super T> action)	对此流的每个元素执行一个操作。
void	forEachOrdered(Consumer<? super T> action)	如果流具有定义的遇到顺序，则按流的遇到顺序对此流的每个元素执行操作。
Stream< T>	limit(long maxSize)	返回由该流的元素组成的流，被截断为maxSize长度不超过。
< R> Stream< R>	map(Function<? super T,? extends R> mapper)	返回由将给定函数应用于此流的元素的结果组成的流。
DoubleStream	mapToDouble(ToDoubleFunction<? super T> mapper)	返回DoubleStream由将给定函数应用于此流的元素的结果组成。
IntStream	mapToInt(ToIntFunction<? super T> mapper)	返回一个IntStream由将给定函数应用于此流的元素的结果组成。
LongStream	mapToLong(ToLongFunction<? super T> mapper)	返回LongStream由将给定函数应用于此流的元素的结果组成。
Optional< T>	max(Comparator<? super T> comparator)	根据提供的 返回此流的最大元素 Comparator。
Optional< T>	min(Comparator<? super T> comparator)	根据提供的 返回此流的最小元素 Comparator。
boolean	noneMatch(Predicate<? super T> predicate)	返回此流的元素是否与提供的谓词匹配。
Stream< T>	peek(Consumer<? super T> action)	返回一个由该流的元素组成的流，另外在每个元素上执行提供的操作，因为元素从结果流中被消耗。
Optional< T>	reduce(BinaryOperator accumulator)	使用关联累积函数对此流的元素 执行缩减，并返回描述缩减的值（如果有）。Optional
T	reduce(T identity, BinaryOperator accumulator)	使用提供的标识值和关联 累积函数对该流的元素 执行归约，并返回归约后的值。
< U> U	reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator combiner)	使用提供的标识、累积和组合函数对该流的元素执行归约。
Stream< T>	skip(long n)	丢弃流的第一个n元素后，返回由该流的其余元素组成的流。
Stream< T>	sorted()	返回由该流的元素组成的流，按自然顺序排序。
Stream	sorted(Comparator<? super T> comparator)	返回由该流的元素组成的流，根据提供的 进行排序Comparator。
Object[]	toArray()	返回一个包含此流元素的数组。
< A> A[]	toArray(IntFunction<A[]> generator)	返回一个包含此流元素的数组，使用提供的generator函数分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。

默认方法

默认方法

修饰符和类型	方法	说明
static < T> Stream.Builder< T>	builder()	返回 a 的构建器Stream。
static < T> Stream< T>	concat(Stream<? extends T> a, Stream<? extends T> b)	创建一个延迟连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
static < T> Stream< T>	empty()	返回一个空的序列Stream。
static < T> Stream< T>	generate(Supplier s)	返回一个无限连续的无序流，其中每个元素都由提供的 生成Supplier。
static < T> Stream< T>	iterate(T seed, UnaryOperator f)	返回一个无限连续有序Stream通过函数的迭代应用产生f为初始元素seed，产生Stream包括seed，f(seed)， f(f(seed))，等。
static < T> Stream< T>	of(T... values)	返回其元素为指定值的顺序有序流。
static < T> Stream< T>	of(T t)	返回一个Stream包含单个元素的序列。

部分用法

创建流

1. 使用Collection下的 stream() 和 parallelStream() 方法

List<String> list = new ArrayList<>();
//顺序流
Stream<String> stream = list.stream(); 
//并行流
Stream<String> parallelStream = list.parallelStream(); 

2. Arrays 中的 stream() 方法

String[] nums = new String["a","b"];
Stream<String> stream = Arrays.stream(nums);

3. Stream中的静态方法：of()、iterate()、generate() 具体参考表格

Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9,10,11,12,13);

Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);
//iterate流迭代器
//limit分页

Stream<Double> stream3 = Stream.generate(Math::random).limit(2);

4. Pattern.splitAsStream() 方法，将字符串分隔成流

Pattern pattern = Pattern.compile(",");
Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");

5. BufferedReader.lines() 方法，将每行内容转成流

BufferedReader reader = new BufferedReader(new FileReader("文本路径"));
Stream<String> lineStream = reader.lines();

方法

forEach

用来迭代流中的每个数据。

Integer[] list = {1,2,3,4,5,6};
        Arrays.stream(list).forEach(l->{
            System.out.println(l-1);
        });

map

接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

Integer[] list = {1,2,3,4,5,6};
        Stream<Integer> stringStream = Arrays.stream(list).map(l->l-1);
        stringStream.forEach(System.out::println);//123456
//通过collect转换成list
        List<Integer> IntegerStream = Arrays.stream(list).map(l->l-1).collect(Collectors.toList());
        System.out.println(IntegerStream);//[0, 1, 2, 3, 4, 5]

filter

用于通过设置的条件过滤出元素

 Integer[] list = {1,2,3,4,5,6};
//筛选数组中大于3的并且转换成list
        List<Integer> IntegerStream = Arrays.stream(list).filter(i->i>3).collect(Collectors.toList());
        System.out.println(IntegerStream);//[4, 5, 6]
//总数
        Long count = Arrays.stream(list).filter(i->i>3).count();
        System.out.println(count);//3
        //也可以联合使用 筛选大于三的并且每个都减去1
        List<Integer> IntegerStream1 = Arrays.stream(list).filter(i->i>3)
                .map(in->in-1).collect(Collectors.toList());
        System.out.println(IntegerStream1);//[3, 4, 5]

limit

用于获取指定数量的流,配合skip跳过多少元素 可分页

Integer[] list = {1,2,3,4,5,6};
        //获取前三个元素
        List<Integer> IntegerStreaml = Arrays.stream(list).limit(3).collect(Collectors.toList());
        System.out.println(IntegerStreaml);//[1, 2, 3]
        //跳过前三个元素
        List<Integer> IntegerStreams = Arrays.stream(list).skip(3).collect(Collectors.toList());
        System.out.println(IntegerStreams);//[4, 5, 6]
        //分页 每页2条数据
        for (int i=1;i<=3;i++){
            System.out.println("第"+i+"页");
            List<Integer> IntegerStreamlimit = Arrays.stream(list).skip((i-1)*2).limit(2).collect(Collectors.toList());
            System.out.println(IntegerStreamlimit);
        }
//第1页
//[1, 2]
//第2页
//[3, 4]
//第3页
//[5, 6]

sorted排序

排序

Integer[] list = {1,3,2,6,5,4};
        //实现自身的Compareable接口排序
        List<Integer> IntegerStreamS = Arrays.stream(list).sorted().collect(Collectors.toList());
        System.out.println(IntegerStreamS);//[1, 2, 3, 4, 5, 6]
        //自定义排序
        List<Integer> IntegerStreamDiy = Arrays.stream(list).sorted((n,a)->a-n).collect(Collectors.toList());
        System.out.println(IntegerStreamDiy);//[6, 5, 4, 3, 2, 1]