标签：正则表达 rar 知识 种类 好的 存在 dom 总数 result
Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，但是将执行操作的时间交给具体实现来决定。例如，如果你希望计算某个方法的平均值，你可以在每个元素上指定调用的方法，从而获得所有值的 平均值。你可以使用Stream API来并行执行操作，使用过多线程来计算每一段的总和与数量，再将结果汇总起来。
一个Stream表面上看与一个集合很类似，允许你改变和获取数据。但是实际上它与集合是有很大区别的：
List<String> 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时，你会通过三个阶段来建立一个操作流水线。
在上面的代码中，通过stream或parallelStream方法来创建Stream，在通过filter方法对其进行转换，而count方法就是终止操作。
Java8在Collection接口中新添加的stream方法，可以将任何集合转化为一个Stream
如果是一个数组，可以用静态的Stream.of方法将它转化为一个Stream;如果需要将数组的一部分转化为Stream，可以使用Arrays.stream()
Stream<String> words = Stream.of(String[] array); Stream<String> words = Stream.of(String ...args); Stream<String> words = Arrays.stream(array, from, to);
要创建一个不含任何元素的Stream，可以使用静态的Stream.empty()
创建无限Stream的静态方法。
generate方法接受一个无参的函数(从技术上说，是一个Supplier <T>接口的对象)。当需要一个Stream值时，就可以调用该方法来产生一个值。
Stream<String> echos = Stream.generate( () -> "Echo");//创建一个含有常量值的Stream Stream<Double> randoms = Stream.generate( Math::random );
iteratre方法接受一个"种子(seed)"值和一个函数(从技术上讲，是一个UnaryOperator<T>接口的对象)作为参数，并且会对之前的值重复应用该函数。例如：
Stream<BigInterger> integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInter.ONE));
在Java8中，添加了许多能够产生Stream的方法。例如，Pattern类添加了一个splitAsStream的方法，能够按照正则表达式对CharSequence(接口，String、StringBuilder和StringBuffer都实现该接口)对象进行分隔。
Stream<String> words = Pattern.compile(",").splitAsStream("abc,def");
Stream转换是指从一个流中读取数据，并将转换后的数据写入另一流中。
filter、map、flatMap方法
filter()
filter方法的参数是一个Predicate<T>对象——即一个从T到Boolean的函数。
List<String> wordList = ...; Stream<String> words = wordList.stream(); Stream<String> longWOrds = words.filter(w -> w.length() > 12);
map()
我们经常需要对一个流中的值进行某种形式的转换。这时可以考虑使用map方法，并传递给它一个执行转换的函数。例如
//使用了带有一个方法引用的map方法 Stream<String> lovercaseWords = words.map(String::toLowerCase); //通常会使用一个lambda表达式来代替方法表达式 Stream<Character> firstChars = words.map(s -> charAt(0)); //该方法产生的流会包含每个单词的第一个字符
flatMap()
假设现在有一个函数，如下：
public static Stream<Character> characterStream(String s) { List<Character> result = new ArrayList<>(); for (char c : s.toCharArray()) result.add(c); return result.stream(); }
调用该方法，如characterStream("boat")会返回流[‘b‘, ‘o‘, ‘a‘, ‘t‘]。假设将该方法映射到一个字符串流上：
Stream<Stream<Character>> result = words.mapo(w -> characterStream(w));
将会得到一个包含多个流的流，如：[..., [‘b‘, ‘o‘, ‘a‘, ‘t‘], ...]。如果要将其展开为一个只包含字符串的流[..., ‘b‘, ‘o‘, ‘a‘, ‘t‘, ...]，则需要使用flatMap方法，而不是map方法：
Stream<Character> letters = words.flatMap(w -> characterStream(w));
提取子流和组合流
Stream<Double> randoms = Stream.generate(Math::random).limit(100);
Stream<String> words = Stream.of("abc", "cdf","ghi").skip(1); //会丢弃掉"abc"
Stream<Character> 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‘]
有状态的转换
之前介绍的流转换都是无状态的，即当从一个已过滤或已映射的流中获取某个元素时，结果并不依赖之前的元素。除此之外，Java8也提供了有状态的转换。
Stream<String> uniqueWords = Stream.of("merrily", "merrily", "gently").distinct();
// 只获取一个"merrily"
Stream<String> longestFirst = words.sorted(Comparator.comparing(String::length).reversed());
前面已经了解任何创###Stream终止操作建流和转换流，接下来将介绍： 如何从数据流数据中找到“答案”。
聚合方法
在本节中介绍的方法统称聚合方法。它们将流聚合为一个值，以便在程序中使用。聚合方法都是终止操作。当一个流应用了终止操作后，它就不能再应用其它操作了。
count()
返回流中元素总数。
long count = Stream.of("abc", "bcd", "cde").count(); //count的结果为 3。
max(), min()
max方法返回流中最大值。min方法返回流中最小值。
需要注意的是，它们返回的是一个Optional<T>值，它可能会封装返回值，也可能表示没有返回(当流为空时)。以前在这种情况通常会返回null，程序拿到该返回值后，进行下一步操作，可能会导致抛出空指针异常。在Java8中，Optional类型时一种更好的表示缺少返回值的方式。
下面是一个如何获得最大值的示例：
Optional<String> largest = Stream.of("abc", "bcd", "cde").max(String::compareToIgnoreCase);
if (largest.isPresent())
System.out.println("largest: " + largest.get());
findFirst(), findAny()
findFirst方法会返回非空集合中的第一个值(通常与filter方法结合使用)；如果想找到所有匹配的元素中的任意一个，那么可以使用findAny方法，这个方法在对流进行并行执行时十分有效，因为只要在任何片段中发现第一个匹配元素，都会结束整个计算。
Optional<String> startsWithQ = Stream.of("abc", Qabc1", "bcd", "Qabc2").parallel().filter(s -> s.startWith("Q")).findAny();
allMatch(), anyMatch()
allMatch方法和anyMatch方法，它们分别在所有元素和没有元素匹配predicate时返回true。虽然这些方法总是会检查整个流，但是仍可以通过并行执行来提高速度。
Optional类型
Optional<T>对象或者是对一个对象的封装，或者表示不是任何对象。它一般比指向T类型的引用更安全，因为它不会反回null。
如果存在被封装的对象，那么get方法会返回该对象，否则会返回一个NoSuchElementException。因此，
Optional<T> optionalValue = ...;
optionalValue.get().someMethod();
并不比下面的方式更安全：
T value = ...;
value.someMethod();
isPresent方法会反映出一个Optional<T>对象是否有值。同样的：
if (optionalValue.isPresent()) optionalValue.get().someMethod();
并不比下面的方式更简单：
if (value != null) value.someMethod();
下面开始了解如何真正使用Optional值。
optionalValue.ifPresent(v -> results.add(v));
//或者
optionalValue.ifPresent(results::add);
Optional<Boolean> added = optionalValue.map(results::add);
因为results.add()返回值是boolean类型，现在added有可能是以下三种值：被封装到Optional中的true或者false，或者是一个空的可选值。
String result = optionalString.orElse("");
// 如果封装的字符串为空的话，则使用给定的空字符串""
String result = optionalString.orElseGet(() -> System.getProperty("user.dir"));
String result = optionalString.orElseThrow(NoSuchElementException::new); //需要提供一个产生异常对象的方法
聚合操作
略
收集结果
当你处理完流之后，通常只是想看一下结果，而不是将它们聚合为一个值。
iterator()
该方法会生成一个传统风格的迭代器，用于访问元素。
toArray()
由于无法在运行时创建一个泛型数组，所以表达式stream.toArray()会返回一个Object[]数组。如果希望得到一个正确类型的数组，可以将类型传递给数组的构造函数：
String[] result = String.of("abc", "bcd", "cde").toArray(String[]::new);
collect()
下面是如何使用HashSet的collect方法的示例：
HashSet<String> result = String.of("abc", "bcd", "abc").collect(HashSet::new, HashSet::add, HashSet::addAll);
List<String> result = String.of("abc", "bcd").collect(Collectors.toList());
Set<String> result = String.of("abc", "bcd", "abc").collect(Collectors.toSet());
如果希望控制得到的set类型，可以使用如下方式：
TreeSet<String> result = String.of("abc", "bcd", "abc").collect(Collectors.toCollection(TreeSet::new));
Map<Integer, String> idToName = persons.collect(Collectors.toMap(Person::getId, Person::getName));
Map<Integer, Person> 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方法。
原始类型流
假设有一个整型数组，并将该数组收集到一个Stream<Integer>的流中，不过奖每个证书包装成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[]数组
并行流
流使得并行计算变得容易。默认情况下，流操作会创建一个串行流，方法Collection.parallelStream()除外。parallel方法可以将任意的串行流转换为一个并行流。例如：
Stream<String> parallelWords = Stream.of(wordArray).parallel();
一个并行流，只要在终止方法执行前，流处于并行模式，那么所有延迟执行的流操作就都会被并行执行。
当并行运行流操作时，需要确保传递给并行流操作的函数都是线程安全的，应当返回与串行运行时相同的结果。很重要的一点是，这些操作都是无状态的，因此可以以任意顺序被执行。
默认情况下，从有序集合、范围值、生成器及迭代器，或者调用Stream.storted所产生的流，都是有序的。有序并不会妨碍并行，例如，当计算stream.map(fun)时，流可以被分为n段，每一段都会被并发处理。然后再按顺序将结果组合起来。
当不考虑有序时，一些操作可以更有效地并行运行。调用Stream.unordered方法可以不关心顺序。比如，可以放弃有序来加快limit方法的速度。如果只需要一个流中的任意n个元素，并不关心具体内容时，可以调用：
Stream<String> stream = stringStream.parallel().unordered().limit(n);
函数式接口
在前文中，你已经了解了许多参数为函数的操作。例如，Stream.filter方法就将一个函数作为参数，filter方法的描述如下：
Stream<T> filter( Predicate<? super T> predicate )
filter方法的使用例子，如下：
Stream<String> longWords = words.filter( s -> s.length() >= 12 ); //words是一个含有多个字符串的流
查看文档可以知道，Predicate是一个接口，只含有一个返回boolean值的非默认方法：
public interface Predicate { boolean test(T argument); }
在实际开发中，开发人员可能会经常传一个lambda表达式或者方法引用，所以方法名并不重要。重要的部分是返回boolean值。当查阅文档时，只需要记住Predicate是一个返回boolean值的函数就行了。
| 函数式接口 | 参数类型 | 返回类型 | 描述 |
|---|---|---|---|
| Supplier<T> | 无 | T | 提供一个T类型的值 |
| Consumer<T> | T | void | 处理一个T类型的值 |
| BiConsumer<T, U> | T, U | void | 处理T类型和U类型的值 |
| Predicate<T> | T | boolean | 一个 计算Boolean值的函数 |
| ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T> |
T | int long double |
分别计算int、long、double值的函数 |
| IntFunction<R> LongFunction<R> DoubleFunction<R> |
int long double |
R | 参数分别为int、long、double类型的函数 |
| Function<T, R> | T | R | 一个参数类型为T的函数 |
| BiFunction<T, U, R> | T, U | R | 一个参数类型为T和U的函数 |
| UnaryOperator<T> | T | T | 对类型T进行的一元操作 |
| BinaryOperator<T> | T, T | T | 对类型T进行的二元操作 |
下表总结了能够作为Stream和Collectors方法参数的函数式接口。
| 函数式接口 | 参数类型 | 返回类型 | 描述 |
|---|---|---|---|
| Supplier<T> | 无 | T | 提供一个T类型的值 |
| Consumer<T> | T | void | 处理一个T类型的值 |
| BiConsumer<T, U> | T, U | void | 处理T类型和U类型的值 |
| Predicate<T> | T | boolean | 一个 计算Boolean值的函数 |
| ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T> |
T | int long double |
分别计算int、long、double值的函数 |
| IntFunction<R> LongFunction<R> DoubleFunction<R> |
int long double |
R | 参数分别为int、long、double类型的函数 |
| Function<T, R> | T | R | 一个参数类型为T的函数 |
| BiFunction<T, U, R> | T, U | R | 一个参数类型为T和U的函数 |
| UnaryOperator<T> | T | T | 对类型T进行的一元操作 |
| BinaryOperator<T> | T, T | T | 对类型T进行的二元操作 |
标签：正则表达 rar 知识 种类 好的 存在 dom 总数 result
原文地址：http://www.cnblogs.com/sprinkle/p/7780206.html
