Java 8 Stream介绍及使用

Posted 2021-01-19 冰冻开水

（原）

stream的内容比较多，先简单看一下它的说明：

A sequence of elements supporting sequential and parallel aggregate
* operations.  The following example illustrates an aggregate operation using
* {@link Stream} and {@link IntStream}:
*
* <pre>{@code
*     int sum = widgets.stream()
*                      .filter(w -> w.getColor() == RED)
*                      .mapToInt(w -> w.getWeight())
*                      .sum();
* }</pre>
* In this example, {@code widgets} is a {@code Collection<Widget>}.  We create
* a stream of {@code Widget} objects via {@link Collection#stream Collection.stream()},
* filter it to produce a stream containing only the red widgets, and then
* transform it into a stream of {@code int} values representing the weight of
* each red widget. Then this stream is summed to produce a total weight.

一个元素的序列，它支持一个串行和并行的聚合操作。下面的例子介绍了使用stream和intstream进行聚合操作。

这个例子里，widgets是一个集合，我们通过Collection.stream()创建了一个Widget的Stream对象。然后过滤了Color属性为RED的对象，然后将其转换成一个int值的Stream，它表示每个红色的重量，然后通过 sum将这些值累加起来。

通过文档能让我们大概的了解stream是怎样操作的。

* <p>In addition to {@code Stream}, which is a stream of object references,
* there are primitive specializations for {@link IntStream}, {@link LongStream},
* and {@link DoubleStream}, all of which are referred to as "streams" and
* conform to the characteristics and restrictions described here.

除了Stream之外（它是一种对象引用流），除此之外，还有一些针对于原生类型的聚化，例如IntStream、LongStream、DoubleStream，它们都被称作为“Stream”,并且它们都遵循这里所描述的stream的特性和限制。

* <p>To perform a computation, stream
* <a href="package-summary.html#StreamOps">operations</a> are composed into a
* <em>stream pipeline</em>.  A stream pipeline consists of a source (which
* might be an array, a collection, a generator function, an I/O channel,
* etc), zero or more <em>intermediate operations</em> (which transform a
* stream into another stream, such as {@link Stream#filter(Predicate)}), and a
* <em>terminal operation</em> (which produces a result or side-effect, such
* as {@link Stream#count()} or {@link Stream#forEach(Consumer)}).
* Streams are lazy; computation on the source data is only performed when the
* terminal operation is initiated, and source elements are consumed only
* as needed.

通过Stream的计算，它的操作会将它组合到一个Stream管道中（Stream特别像Linux里面管道的概念），一个流的管道包含的源可能是一个数组、一个集合、一个函数或是IO channel，在Stream的计算中可能会包括一个或多个中间操作（这些中间操作会将这个Stream转换成另一个Stream，例如通过Stream#filter(Predicate)），和一个中止操作(它会产生一个结果，如Stream#count())，Stream是惰性和，它的源数据只有在终止操作初始化的时候才执行，源数据只有被需要的时候才会被消费。

上面的意思是说，比如。Stream.aaa().bbb().ccc().count();

aaa,bbb,ccc方法为Stream的中间操作。在最的一个count未被调用时，这些中间操作是不会被执行的，这意味这count是一个终止操作。

根据文档的描述，Stream的计算由三部分组中：

1、     源数据

2、     中间操作

3、     终止操作

这里的中间操作属于惰性求值，而终止操作属于及早求值。

那么Stream要怎样创建呢？

看这个方法：

/**
 * Returns a sequential ordered stream whose elements are the specified values.
 *
 * @param <T> the type of stream elements
 * @param values the elements of the new stream
 * @return the new stream
 */

@SafeVarargs

@SuppressWarnings("varargs") // Creating a stream from an array is safe

public static<T> Stream<T> of(T... values) {

    return Arrays.stream(values);

}

根据指定的元素返回一个有序有Stream

于是我们可以这样创建：

Stream stream1 = Stream.of("zhangsan", "lisi", "wangwu");

或者

String[] str2 = {"zhangsan", "lisi", "wangwu"};

Stream stream2 = Stream.of(str2);

或者通过List.stream()

List list3 = Arrays.asList("zhangsan", "lisi", "wangwu");

Stream stream3 = list3.stream();

我们通过IntStream创建流并将其输出：

IntStream.of(3,1,4,9).forEach(System.out::println);

在IntStream中有range和rangeClosed二个方法，接收二个参数，代表着一个整数区间范围，range表示不包含最后一位，rangeClosed表示包含最后一位。

IntStream.range(1,4).forEach(System.out::println);

System.out.println("---");

IntStream.rangeClosed(1,4).forEach(System.out::println);

如果现在有一个Int集合，要让集合里面的所有数值乘以2再相加得到最后的结果，用以前的写法不得不用循环的方式这么写：

List<Integer> partList3 = Arrays.asList(1,2,3);

Integer sum3 = 0;

for (Integer o : partList3) {

    sum3 += o * 2;

}

而通过Stream可以化成一行代码：

Integer sum33 = partList3.stream().map(integer -> integer * 2).reduce(0,Integer::sum);

/**
 * Returns a stream consisting of the results of applying the given
 * function to the elements of this stream.
 *
 * <p>This is an <a href="package-summary.html#StreamOps">intermediate
 * operation</a>.
 *
 * @param <R> The element type of the new stream
 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
 *               <a href="package-summary.html#Statelessness">stateless</a>
 *               function to apply to each element
 * @return the new stream
 */

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

这里的map方法接收一个Function参数，最后会返回一个Stream对象，记住，这里是一个中间操作。Map方法中的Function函数会传入一个参数，然后返回把这个参数经过处理后的结果，reduce方法是一个终止操作，将这些值都通过方法引用Integer::sum的方式加起来。其中reduce接收二个参数：

  T reduce(T identity, BinaryOperator<T> accumulator);

第一个参数可以认为是初始值，第二个参数是计算方式的函数，计算结果等价于：

T result = identity;
for (T element : this stream)
    result = accumulator.apply(result, element)
    return result;
}

如果将一个Stream对象转成一数组?

Stream<String> stream4 = Stream.of("a", "k", "g", "b");

Stream中有一个toArray方法。

/**
 * Returns an array containing the elements of this stream, using the
 * provided {@code generator} function to allocate the returned array, as
 * well as any additional arrays that might be required for a partitioned
 * execution or for resizing.
 *
 * <p>This is a <a href="package-summary.html#StreamOps">terminal
 * operation</a>.
 *
 * @apiNote
 * The generator function takes an integer, which is the size of the
 * desired array, and produces an array of the desired size.  This can be
 * concisely expressed with an array constructor reference:
 * <pre>{@code
 *     Person[] men = people.stream()
 *                          .filter(p -> p.getGender() == MALE)
 *                          .toArray(Person[]::new);
 * }</pre>
 *
 * @param <A> the element type of the resulting array
 * @param generator a function which produces a new array of the desired
 *                  type and the provided length
 * @return an array containing the elements in this stream
 * @throws ArrayStoreException if the runtime type of the array returned
 * from the array generator is not a supertype of the runtime type of every
 * element in this stream
 */
<A> A[] toArray(IntFunction<A[]> generator)

这里除了使用之前说过的这种方式。

String[] streamArr1 = stream4.toArray(len -> new String[len]);

因为IntFunction这个函数接收一个Int类型为数组长度，返回一个数组的类型，我们也可以用文档中提供的例子这种方法。

String[] streamArr2 = stream4.toArray(String[]::new);

如果将一个Stream转换成List

Stream中提供了2个重载的方法

<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
 
<R, A> R collect(Collector<? super T, A, R> collector);

下面一个方法可以看作是上面的缩写形式，

第一个方法中，文档中如此描述：

Performs a <a href="package-summary.html#MutableReduction">mutable
* reduction</a> operation on the elements of this stream.  A mutable
* reduction is one in which the reduced value is a mutable result container,
* such as an {@code ArrayList}, and elements are incorporated by updating
* the state of the result rather than by replacing the result.  This
* produces a result equivalent to:
* <pre>{@code
*     R result = supplier.get();
*     for (T element : this stream)
*         accumulator.accept(result, element);
*     return result;
* }</pre>

对这个流中的元素执行一个可变的汇聚的操作，一个可变的汇聚的操作指的是被汇聚的值是一个可变的结果容器，比如ArrayList, 这个集合是通过更新结果状态来合并的，而不是通过替换这个结果来合并的，这个结果等同于：

R result = supplier.get();
   for (T element : this stream)
        accumulator.accept(result, element);
   return result;
 }

参数1：Supplier，返回的对象是该方法返回的对象类型。

参数2:BiConsumer,接收的第一个参数可以理解是一个需要汇聚的对象，第二个参数是stream中的某一个元素。

参数3：BiConsumer，相当于是一个合并器，将上一次的结果和装进同一个对象中，用于最后的返回。当然这个对象的类型就是Supplier返回的对象类型。

例如这样：

Stream<String> stream5 = Stream.of("hello", "world", "good", "morning");

List<String> list5 = stream5.collect(() -> new ArrayList<>(),(list1,item) -> list1.add(item),(list2,list1) -> list2.addAll(list1));

list5.forEach(System.out::println);

这里有个简单的方法可以替代以上的代码

Stream<String> stream444 = Stream.of("list1", "list2", "list3");
List<String> list444 = stream444.collect(Collectors.toList());
list444.forEach(System.out::println);

Collectors中有很多方法，toList()只是将stream中的值存入ArrayList中返回。

如果想要换成LinkedList,可以用Collectors.toCollection(LinkedList::new)

如果要将里面的值拼接成一个字符串返回，可以用Collectors.joining()

在stream中，map作为一个映射方法，可以将集合中的无素作相处理，但如果集合中的每个元素都是一个list，要将这些list中的元素合并成一个集合，以前的做法就是用list.addAll()这个方法，现在可以利用stream中的另一个映射方法，floatMap.

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

它接收一个 Function函数，返回值为stream

于是可以这样写:

Stream<List<Integer>> stream7 = Stream.of(Arrays.asList(1,2), Arrays.asList(3), Arrays.asList(4,5));
List<Integer> list7 = stream7.flatMap(list -> list.stream()).collect(Collectors.toList());
System.out.println(list7);

将每个stream中的元素都展开，放在一个stream中，最后用collect方法放一个集合中输出。

stream中另一些比较常用的方法.

1、

public static<T> Stream<T> generate(Supplier<T> s) 

通过generate返回一个Stream对象，接收一个 Supplier函数

例如：

Stream stream8 = Stream.generate(UUID.randomUUID()::toString);

2、

Optional<T> findFirst(); 

This is a short-circuiting terminal operation

这是一个终止操作，返回一个Optional，为什么是Optional而不是一个对象T呢？因为Stream中可能会有空的情况，就像这样Stream stream8 = Stream.empty();

如果是这样，那么findFirst()可能会返回null值，所以才用了Optional来规避空值的情况。

例如：

Stream stream8 = Stream.generate(UUID.randomUUID()::toString);
stream8.findFirst().ifPresent(System.out::println);

3、

public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

Returns an infinite sequential ordered {@code Stream} produced by iterative
application of a function {@code f} to an initial element {@code seed}

producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
*{@code f(f(seed))}, etc.

用这个种子元素seed,通过迭代f，返回一个无限的串行的有序的流元素,

最后的stream的结果是一个seed ,f(seed),f(f(seed)) … 的结果。

由于这个方法是无限循环的，所以往往会跟limit终止操作配合使用。

它的第2个参数UnaryOperator是这样定义的：

public interface UnaryOperator<T> extends Function<T, T>

如果它的apply方法接收参数和返回参数是同一类型，是一个一元的Function函数

例如:

Stream.iterate(1,i -> i + 2).limit(3).forEach(System.out::println);

返回的结果将是1、3、5。

4、

Stream<T> limit(long maxSize);

Returns a stream consisting of the elements of this stream, truncated
to be no longer than {@code maxSize} in length

返回一个长度不超过给定参数maxSize大小的stream

Stream<T> skip(long n);

Returns a stream consisting of the remaining elements of this stream
after discarding the first {@code n} elements of the stream

返回一个丢弃了前n个元素之后的stream。

例如：用iterate生成一个从1开始往后加1的stream，先限定这个stream长度为5，再忽略前2个，取后3个元素输出。

Stream.iterate(1, i -> i + 1).limit(5).skip(2).forEach(System.out::println);

5、

Stream<T> distinct()

没啥说的，去重用的。

例如：

IntStream.of(1,1,3,4,5,6,4).distinct().forEach(System.out::println);

返回1，3，4，5，6

6 、

Optional<T> max(Comparator<? super T> comparator)
Optional<T> min(Comparator<? super T> comparator)

求最大最小值，一般而言，如果是数字可用IntStream,IntStream中的求最大值，最小值是不带参数的，max(),min(),另外还提供了一个sum()求和方法。

如果IntStream是一个空对象，那么sum可以返回0,而min,max是一个null , 所以这里sum的返回值用的是int，而min和max返回值是OptionalInt，用于规避值为null的情况，所以一般可以这么写.

IntStream.of(1,2,3,4,5).max().ifPresent(System.out::println);

针对于IntStream的统计方法，它还额外提供了一个方法：

IntSummaryStatistics summaryStatistics()

IntSummaryStatistics 这个类，它也提供了数值统计的常用方法，如count,sum,min,max ,average等

例如：

IntSummaryStatistics intSummaryStatistics = IntStream.of(1, 2, 3, 4, 5).summaryStatistics();
System.out.println(intSummaryStatistics.getMax());
System.out.println(intSummaryStatistics.getMin());
System.out.println(intSummaryStatistics.getAverage());

 

 例子请看这里：https://github.com/LeeScofield/java8