Stream基础知识

Stream API

Stream是Java8中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,但是将执行操作的时间交给具体实现来决定。例如,如果你希望计算某个方法的平均值,你可以在每个元素上指定调用的方法,从而获得所有值的 平均值。你可以使用Stream API来并行执行操作,使用过多线程来计算每一段的总和与数量,再将结果汇总起来。

一个Stream表面上看与一个集合很类似,允许你改变和获取数据。但是实际上它与集合是有很大区别的:

  1. Stream自己不会存储元素。元素可能被存储在底层的集合中,或者根据需要产生出来。
  2. Stream操作符不会改变源对象。相反,它们会返回一个持有结果的新Stream。
  3. Stream操作符可能是延迟执行的。这意味者它们会等到需要结果的时候才执行。例如你只想要前5个长单词,而不需要统计所有长字符,那么filter方法将会在5次匹配后停止过滤。因此,甚至可以有无限的Stream。
List words = ...;
//Java8在Collection接口中新添加的stream方法,可以将任何集合转化为一个Stream
long count = words.stream().filter(w -> w.length() > 12).count();

//将stream方法改成parallel Stream方法,就可以让StreamAPI并行执行过滤和统计操作。
long count = words.vStream().filter(w -> w.length() > 12).count();

Stream遵循“做什么,而不是怎么去做”的原则。上面的代码中,描述了需要做什么:获的长单词并对它们的个数进行统计。我们没有制定按照什么顺序,或者在哪个线程中做,它们都是理所应当发生的。相反,循环在一开始就需要指定如何进行运算,因此就是去了优化的机会。
当你使用Stream时,你会通过三个阶段来建立一个操作流水线。

  1. 创建一个Stream
  2. 在一个或多个步骤中,指定将初始Stream转换为另一个Stream的中间操作。
  3. 使用一个终止操作来产生一个结果。该操作会强制它之前的延迟操作立即执行。在这之后,该Stream就不会再被使用了

在上面的代码中,通过stream或parallelStream方法来创建Stream,在通过filter方法对其进行转换,而count方法就是终止操作。

创建Stream

  1. Java8在Collection接口中新添加的stream方法,可以将任何集合转化为一个Stream
  2. 如果是一个数组,可以用静态的Stream.of方法将它转化为一个Stream;如果需要将数组的一部分转化为Stream,可以使用Arrays.stream()
Stream words = Stream.of(String[] array);
Stream words = Stream.of(String ...args);
Stream words = Arrays.stream(array, from, to);
  1. 要创建一个不含任何元素的Stream,可以使用静态的Stream.empty()
  2. 创建无限Stream的静态方法。
  • generate方法接受一个无参的函数(从技术上说,是一个Supplier 接口的对象)。当需要一个Stream值时,就可以调用该方法来产生一个值。
Stream echos = Stream.generate( () -> "Echo");//创建一个含有常量值的Stream
Stream randoms = Stream.generate( Math::random );
  • iteratre方法接受一个"种子(seed)"值和一个函数(从技术上讲,是一个UnaryOperator接口的对象)作为参数,并且会对之前的值重复应用该函数。例如:
Stream integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInter.ONE));

在Java8中,添加了许多能够产生Stream的方法。例如,Pattern类添加了一个splitAsStream的方法,能够按照正则表达式对CharSequence(接口,String、StringBuilder和StringBuffer都实现该接口)对象进行分隔。

Stream words = Pattern.compile(",").splitAsStream("abc,def");

Stream的转换

Stream转换是指从一个流中读取数据,并将转换后的数据写入另一流中。

  1. filter、map、flatMap方法
  • filter()
    filter方法的参数是一个Predicate对象——即一个从T到Boolean的函数。
List wordList = ...;
Stream words = wordList.stream();
Stream longWOrds = words.filter(w -> w.length() > 12);
  • map()
    我们经常需要对一个流中的值进行某种形式的转换。这时可以考虑使用map方法,并传递给它一个执行转换的函数。例如
//使用了带有一个方法引用的map方法
Stream lovercaseWords = words.map(String::toLowerCase);
//通常会使用一个lambda表达式来代替方法表达式
Stream firstChars = words.map(s -> charAt(0)); //该方法产生的流会包含每个单词的第一个字符
  • flatMap()
    假设现在有一个函数,如下:
public static Stream characterStream(String s) {
    List result = new ArrayList<>();
    for (char c : s.toCharArray()) result.add(c);
    return result.stream();
}

调用该方法,如characterStream("boat")会返回流['b', 'o', 'a', 't']。假设将该方法映射到一个字符串流上:

Stream> result = words.mapo(w -> characterStream(w));

将会得到一个包含多个流的流,如:[..., ['b', 'o', 'a', 't'], ...]。如果要将其展开为一个只包含字符串的流[..., 'b', 'o', 'a', 't', ...],则需要使用flatMap方法,而不是map方法:

Stream letters = words.flatMap(w -> characterStream(w));
  1. 提取子流和组合流
  • limit()
    Stream.limit(n)会返回一个包含n个元素的新流(如果原始长度小于m,则返回原始的流)。这个方法特别适用于裁剪指定长度的流。例如产生一个包含100个随机数字的流:
Stream randoms = Stream.generate(Math::random).limit(100);
  • skip()
    Stream.skip(n)正好相反,它会丢掉前面的n个元素。
Stream words = Stream.of("abc", "cdf","ghi").skip(1); //会丢弃掉"abc"
  • concat()
    Stream.concat(Stream, Stream)将两个流连接到一起。注意,第一个流的长度不应该是无限的,否则第二个流旧永远没有机会被添加到第一个流后面。
Stream combined = Stream.concat(Stream.of('H', 'e', 'l', 'l', 'o'), Stream.of('W', 'o', 'r', 'l', 'd'));
//产生一个新流['H', 'e', 'l', 'l', 'o','W', 'o', 'r', 'l', 'd']
  1. 有状态的转换
    之前介绍的流转换都是无状态的,即当从一个已过滤或已映射的流中获取某个元素时,结果并不依赖之前的元素。除此之外,Java8也提供了有状态的转换。
  • distinct()
    distinct方法会根据原始流中的元素返回一个具有相同顺序、抑制了重复元素的新流。显然,该流必须记住之前已读取的元素。
Stream uniqueWords = Stream.of("merrily", "merrily", "gently").distinct();
// 只获取一个"merrily"
  • sorted()
    sorted方法必须遍历整个流,并在产生任何元素之前对它进行排序。显然,无法对一个无限流进行排序。
Stream longestFirst = words.sorted(Comparator.comparing(String::length).reversed());

Stream终止操作

前面已经了解任何创###Stream终止操作建流和转换流,接下来将介绍: 如何从数据流数据中找到“答案”。

  1. 聚合方法
    在本节中介绍的方法统称聚合方法。它们将流聚合为一个值,以便在程序中使用。聚合方法都是终止操作。当一个流应用了终止操作后,它就不能再应用其它操作了。
  • count()
    返回流中元素总数。
long count = Stream.of("abc", "bcd", "cde").count(); //count的结果为 3。
  • max(), min()
    max方法返回流中最大值。min方法返回流中最小值。
    需要注意的是,它们返回的是一个Optional值,它可能会封装返回值,也可能表示没有返回(当流为空时)。以前在这种情况通常会返回null,程序拿到该返回值后,进行下一步操作,可能会导致抛出空指针异常。在Java8中,Optional类型时一种更好的表示缺少返回值的方式。
    下面是一个如何获得最大值的示例:
Optional largest = Stream.of("abc", "bcd", "cde").max(String::compareToIgnoreCase);
if (largest.isPresent())
    System.out.println("largest: " + largest.get());
  • findFirst(), findAny()
    findFirst方法会返回非空集合中的第一个值(通常与filter方法结合使用);如果想找到所有匹配的元素中的任意一个,那么可以使用findAny方法,这个方法在对流进行并行执行时十分有效,因为只要在任何片段中发现第一个匹配元素,都会结束整个计算。
Optional startsWithQ = Stream.of("abc",  Qabc1", "bcd", "Qabc2").parallel().filter(s -> s.startWith("Q")).findAny();
  • allMatch(), anyMatch()
    allMatch方法和anyMatch方法,它们分别在所有元素和没有元素匹配predicate时返回true。虽然这些方法总是会检查整个流,但是仍可以通过并行执行来提高速度。
  1. Optional类型
    Optional对象或者是对一个对象的封装,或者表示不是任何对象。它一般比指向T类型的引用更安全,因为它不会反回null。
    如果存在被封装的对象,那么get方法会返回该对象,否则会返回一个NoSuchElementException。因此,
Optional optionalValue = ...;
optionalValue.get().someMethod();

并不比下面的方式更安全:

T value = ...;
value.someMethod();

isPresent方法会反映出一个Optional对象是否有值。同样的:

if (optionalValue.isPresent()) optionalValue.get().someMethod();

并不比下面的方式更简单:

if (value != null) value.someMethod();

下面开始了解如何真正使用Optional值。

使用Optional

高效使用Optional的关键在于,使用一个或者接受正确值、或者返回另一个替代值的方法。

  • ifPresent()
    ifPresent方法可以接受一个函数。如果存在可选值,那么它会将该值传递给函数,否则不会进行任何操作。例如,如果希望在当有值存在时将它添加到一个集合中,可以调用:
optionalValue.ifPresent(v -> results.add(v));
//或者
optionalValue.ifPresent(results::add);
  • map()
    当调用ifPresent方法时,不会反回任何值。如果你希望对结果进行处理,可以使用map方法。
Optional added = optionalValue.map(results::add);

因为results.add()返回值是boolean类型,现在added有可能是以下三种值:被封装到Optional中的true或者false,或者是一个空的可选值。

  • orElse()
    已经了解了当一个可选值存在时应该如何对它优雅地进行处理。另一种使用可选值的方式是,当没有值存在时,产生一个替代值。通常,当没有可匹配项时,会希望使用一个默认值,例如一个空字符串:
String result = optionalString.orElse("");
// 如果封装的字符串为空的话,则使用给定的空字符串""
  • orElseGet()
    当没有值存在时,还可以调用代码来计算
String result = optionalString.orElseGet(() -> System.getProperty("user.dir"));
  • orElseThrow()
    当没有值存在时,会抛出一个指定的异常。
String result = optionalString.orElseThrow(NoSuchElementException::new);
//需要提供一个产生异常对象的方法

创建可选值

之前已经讨论了如何处理一个已存在的Optional对象。接下来说明如何创建一个Optional对象。

  • Optional.of(obj),Optional.empty()
    of方法创建一个封装了obj的Optional对象,empty方法创建一个”空"的Optional对象。
  • Optional.ofNullable()
    ofNullable方法被设计为null值和可选值之间的一座桥梁。如果obj不为null,那么Optional.ofNullable(obj)会返回Optional.of(obj),否则会返回Optional.empty()。
  • 使用flatMap来组合可选值函数
    暂略。
  1. 聚合操作
    略。
  2. 收集结果
    当你处理完流之后,通常只是想看一下结果,而不是将它们聚合为一个值。
    iterator()
    该方法会生成一个传统风格的迭代器,用于访问元素。
    toArray()
    由于无法在运行时创建一个泛型数组,所以表达式stream.toArray()会返回一个Object[]数组。如果希望得到一个正确类型的数组,可以将类型传递给数组的构造函数:
String[] result = String.of("abc", "bcd", "cde").toArray(String[]::new);

collect()

  • collect(Supplier, BiConsumer, BiConsumer)
    该方法接收三个参数:

    1. 一个能创建目标类型实例的方法,例如HashSet的构造方法
    2. 一个将元素添加到目标中的方法,例如一个add方法
    3. 一个将两个对象整合到一起的方法,例如addAll方法

    下面是如何使用HashSet的collect方法的示例:

HashSet result = String.of("abc", "bcd", "abc").collect(HashSet::new, HashSet::add, HashSet::addAll);
  • collect(Collector)
    上面介绍了需要接收三个参数的collect方法,在实际中,并不需要这么做,因为Collector接口已经为我们提供了这三个方法,并且Collectors类还为常用的手机类型提供了各个工厂方法。
    要将一个流收集到一个list或者set中,只需要调用:
List result = String.of("abc", "bcd").collect(Collectors.toList());
Set result = String.of("abc", "bcd", "abc").collect(Collectors.toSet());

如果希望控制得到的set类型,可以使用如下方式:

TreeSet result = String.of("abc", "bcd", "abc").collect(Collectors.toCollection(TreeSet::new));

假设有一个Steam对象,并且希望将其中的元素收集到一个map中,这样随后可以通过它们的id来查找。Collectors.toMap方法有两个函数参数,分别用来生成map的键和值。例如:

Map idToName = persons.collect(Collectors.toMap(Person::getId, Person::getName));
Map idToPerson = persons.collect(Collectors.toMap(Person::getId, Function.identity()));

forEach(), forEachOrdered()
当只要将它们打印出来,或逐个遍历它们,那么可以使用forEach方法,如下:

Stream.of("abc", "bcd", "cdf").forEach(System.out::println);

向该方法传递的函数会被应用到流中的每个元素上。需要注意的是,在一个并行流上,要确保该函数可以被并发执行。
在一个并行流上,可能会以任意的顺序来访问元素。如果希望按照流的顺序来执行它们,那么可以使用forEachOrdered方法。
forEach方法和forEachOrdered方法都是终止操作。因此在调用它们之后,就不能再使用这个流了。如果希望还能继续使用这个流,请使用peek方法。

其他

  1. 原始类型流
    假设有一个整型数组,并将该数组收集到一个Stream的流中,不过奖每个证书包装成Integer对象显然是一个低效的做法,对于其他原始类型double、float、long、short、char、byte及boolean也是一样。为此,Stream API提供了IntStream和LongStream和DoubleStream三种类型,专门用来直接存储原始类型值,不必使用包装,而Stream API设计者认为不需要为其它5种原始类型都添加对应的专门类型。

    要创建一个IntStream,可以调用IntStream.of和Arrays.stream方法:

IntStream stream = IntStream.of(1, 3, 5, 7);
IntStream stream = Arrays.stream(values, from, to); // values是一个int[]数组
  1. 并行流
    流使得并行计算变得容易。默认情况下,流操作会创建一个串行流,方法Collection.parallelStream()除外。parallel方法可以将任意的串行流转换为一个并行流。

    一个并行流,只要在终止方法执行前,流处于并行模式,那么所有延迟执行的流操作就都会被并行执行。

    当并行运行流操作时,需要确保传递给并行流操作的函数都是线程安全的,应当返回与串行运行时相同的结果。很重要的一点是,这些操作都是无状态的,因此可以以任意顺序被执行。

    默认情况下,从有序集合、范围值、生成器及迭代器,或者调用Stream.storted所产生的流,都是有序的。有序并不会妨碍并行,例如,当计算stream.map(fun)时,流可以被分为n段,每一段都会被并发处理。然后再按顺序将结果组合起来。

    当不考虑有序时,一些操作可以更有效地并行运行。调用Stream.unordered方法可以不关心顺序。比如,可以放弃有序来加快limit方法的速度。如果只需要一个流中的任意n个元素,并不关心具体内容时,可以调用:

Stream stream = stringStream.parallel().unordered().limit(n);
  1. 函数式接口
    在前文中,你已经了解了许多参数为函数的操作。例如,Stream.filter方法就将一个函数作为参数,filter方法的描述如下:
Stream filter( Predicate predicate )

filter方法的使用例子,如下:

Stream longWords = words.filter( s -> s.length() >= 12 );
//words是一个含有多个字符串的流

查看文档可以知道,Predicate是一个接口,只含有一个返回boolean值的非默认方法:

public interface Predicate {
        boolean test(T argument);
}

在实际开发中,开发人员可能会经常传一个lambda表达式或者方法引用,所以方法名并不重要。重要的部分是返回boolean值。当查阅文档时,只需要记住Predicate是一个返回boolean值的函数就行了。

下表总结了能够作为Stream和Collectors方法参数的函数式接口。

函数式接口 参数类型 返回类型 描述
Supplier T 提供一个T类型的值
Consumer T void 处理一个T类型的值
BiConsumer T, U void 处理T类型和U类型的值
Predicate T boolean 一个 计算Boolean值的函数
ToIntFunction
ToLongFunction
ToDoubleFunction
T int
long
double
分别计算int、long、double值的函数
IntFunction
LongFunction
DoubleFunction
int
long
double
R 参数分别为int、long、double类型的函数
Function T R 一个参数类型为T的函数
BiFunction T, U R 一个参数类型为T和U的函数
UnaryOperator T T 对类型T进行的一元操作
BinaryOperator T, T T 对类型T进行的二元操作

你可能感兴趣的:(Stream基础知识)