陕西铝单板厂家联系电话欢迎您的咨询来电（流注的特点是）

流的基本概念流是一种指定的计算视图流遵循“做什么而非怎么做”的原则，它比循环更易于阅读可以让你以一种声明的方式处理数据例如代码：有一个变量名为 words，它是一个集合，里面一本书中所有的单词，需要找出单词长度大于12的单词数量。

循环long count = 0; for (String w : words) { if (w.length > 12) count++;}流letcount = words.stream() .filter

(w -> w.length > 12) .count();典型流程由上述示例代码可知，流的典型流程：创建一个流：words.stream()指定将初始化流转换为其它流的中间操作（可能包含多个步骤）：.filter(w -> w.length > 12)

应用终止操作，从而产生结果这个操作会强制执行之前的惰性操作从此之后，这个流就再也不能使用了：.count();流与集合的区别流并不存储元素，这些元素可能存储在底层的集合中，或者是按需生成的流的操作不会修改其数据源 例如，filter() 方法不会从新的流中移除元素，而是会生成一个新的流，其中不包含被过滤掉的元素。

流程的操作是尽可能惰性执行的这意味着直至需要其结果时，操作才会执行流的常见应用创建流流有很多创建方式，举几个例子：创建任意数量的流量Stream word = Stream. of("1231254135"

.split("1"));从数组的指定位置创建流程Stream song = Array.stream(words, 1, 3);创建空流Stream silence = Stream.emty();

FunctionSupplierStream echos = Stream.generate(() －＞"Echo");Stream randoms = Stream.generate(

Math::random);UnaryOperationStream intergers = Stream.iterate(BigInteger.ZERO, n -> n.

add(BigInteger.ONE));上述代码使用iterate方法创建了一个无限序列（0 1 2 3 4 5...）第一个参数是种子 BigInteger.ZERO，第二个元素是 f(seed)，即1，下一个元素是f(f(seed))，依次类推。

Pattern正则分割产生流Stream words = Pattern.compile("\PL+") .splitAsStream(contents);操作流常用的是几个操作流的方法。

filter过滤流中的元素Stream longWords = words.stream().filter(w -> w.length > 12);map转换流中元素// 流中所有的单词转换为小写Stream 1 owe caseWords = words.stream().map(String::toLowerCase);

// 流中所有的单词，通过截取字符串，转换为首字母Stream firstLette = wordds.stream().map(s -> s.substring(O, 1));flatMap

通过传入参数（Function mapper），将流中所有的元素产生的结果连接在一起产生一个新的流例如：letters方法，将单词转为字母流返回letters("boat")的返回值是：流["b", "o", "a", "t"]。

publicstatic Stream letters(String s) { List result = new ArrayList<>(); for (int i =

0; i < s.length); i++) result.add(s.substring(i, i +1)); } return result.stream();}使用words单词流调用letters方法，将会返回一个包含流的流Stream

Stream result = words.stream().map(w -> letters(w));上面代码的结果并不是我们想要的，我们想要的是单词流转为字母流，而不是一个流中还包含另一个流。

这时就需要使用到 flatMap 方法，此方法会摊平流中包含的字母流将流：[["y", “o”, "u", "r"], ["b", "o", "a", "t"]] 摊平为 ["y", “o”, "u", "r","b", "o", "a", "t"]。

Stream result = words.stream().flatMap(w -> letters(w));limit(n)丢弃第 n 个位置之后的元素// 截止到第 100 个元素，创建流Stream randoms = Stream.generate(Math::random).

limit(100)skip(n)与 limit 相反，丢弃第 n 个位置之前的元素// 跳过第1个元素，创建流Stream words = Stream.of(content.split

("\PL+")).skip(1)concat连接流Stream word = Stream.concat(lettes("Hello"), letters("World"))distinct

去重Stream uniqueWords = Stream.of("a", "a", "b").distinct()sort排序// 按单词长度，从短到长升序Stream longesFirst = words.stream().sorted(Comparator.comparing(String::length))

peek在每次访问一个元素时，都会调用peek方法中的函数，对于调试来说非常方便Object[] powers = Stream.iterate(1.O, p -> p * 2) .peek(e -> System.out.println(。

"Fetching " + e)) .limit(20).toArray();简单约简/终止操作约简直是一种终结操作（ terminal operation ），它们会将流约简为可以在程序中使用的非流值。

count返回流中元素的数量max返回流中最大的元素min返回流水中最小的元素findFirst找到流中的第一个元素findAny找到流水中的任意一个元素anyMatch根据指定参数（匹配条件），判断流水中是否含有元素符合

allMatch根据指定参数（匹配条件），判断流程中是否所有元素符合noneMatch根据指定参数（匹配条件），判断流程中是否所有元素都不符合收集结果forEach此方法会将传入的函数，应用于每个元素stream

.forEach(System.out::println);toArray返回 Object[] 数组String[] result = stream.toArray(String[]::new)collect

将流水中的元素收集到另一个目标stream.collect(Collectors.tolist());控制获得结果集的类型TreeSet result = stream.collect(Collectors.toCollection(TreeSet::

new));收集流传中的字符串String result = stream.collect(Collectors.joining())元素间加入分隔符收集结果String result = stream.collect(Collectors.joining(

"、"))将其它类型的对象，转为字符串收集String result = stream.map(Object::toString).collect(Collectors.joining("、"))如果要将流的结果约简为总和、平均值、最大值或最小值，可以使用summarizing(Int|Long|Double)方法中的某一个。

IntSummaryStatistics summary = stream.collect(Collectors.summarizingInt(String::length));double averageWordLength = summary.getAverage();

double maxWordLength = summary.getMax();收集至Map使用 Collectors.toMap，可以将想要的元素收集至 Map 中Map

> idToName = people.collect(Collectors.toMap(Person::getId, Person::getName));Map idToPerson = people.collect(Collectors.toMap(Person::getId,

Function.identity()));一个key，多个value通过第三个参数，传入的函数，控制当一个key，存在多种value的情况Stream locales = Stream.of(Locale.getAvailableLocales()); Map<。

String, String> languageNames = locales.collect( Collectors.toMap( Locale::getDisplayLanguage, l -> l.getDisplayLanguage(l), (existingValue, newValue) -> existingValue))

控制指定收集 TreeMap 类型数据Map idToPerson = people.collect( Collectors.toMap( Person::getId,

Function.identity(), (existingValue, newValue) -> { thrownew IllegalStateException(); }, TreeMap::new));

对于每一个 toMap 方法，都有一个等价的可以产生并发映射表的 toConcurrentMap方法单个并发映射表可以用于并行集合处理当使用并行流时，共享的映射表比合并映射表要更高效 注意，元素不再是按照流程中的顺序收集的，但是通常这不会有什么问题。

群组与分区将需要相同数量的元素，分成一组可以使用 groupingBy 方法Stream locales = Stream.of(Locale.getAvailableLocales()); 。

Map countryToLocales = locales.collect( Collectors.groupingBy(Locale::getCountry));

当要分组的 key 为 boolean 类型时，使用 partitioningBy 更加高效Map englishAndOtherLocales = locales.collect( Collectors.partitioningBy(l -> l.getLanguage().。

equals("en"))); List englishLocales = englishAndOtherLocales.get(true);如果调用 groupingByConcurrent 方法，就会在使用并行流时获得一个被并行组装的并行映射表。

这与 toConcurrentMap 方法完全类似下游收集器如果要控制分组的 value 时，需要提供一个“下游收集器（downstream collector）”例如我们想收集的value 为 set 类型，而非列表list。

Map countryToLocaleSet = locales.collect(Collectors.groupingBy(Locale::getCountry, Collectors.toSet()));

除了可以使用 toSet()，也可以使用 counting、summingInt、maxBy 等约简方法mapping此方法会将传入的函数，应用到下游收集器的结果上例如：还是上面的程序，我们想收集Map类型，其中key是字符串，value 是 Set 类型。

import java.util.stream.Collectors.* ... Map countryToLanguages = locales.collect(groupingBy(Locale::getDisplayCountry,mapping(Locale::getDisplayLanguage,toSet())));

约简操作reduce 方法，支持自定义约简函数List values = . . .; // 计算流中元素的和Optional sum = values.stream().reduce(Integer::sum)。

上述代码，如果流中的元素用V表示，具体在流中就会执行 V0 + V1 + V2 + ... Vi 个元素如果流为空，就会返回一个 Optional 里面为空的对象在实践中，建议通过 toMap()，转为数字流，并使用其自带的求和、最大值、最小值等方法更容易。

基本类型流在流库中，有针对基本数据类型使用的流类型IntStream、LongStream、DoubleStream，用来直接存储基本类型值，而无需使用包装器，如果想要存储 short、char、byte、boolean，可以使用 IntStream ，而对于float ，可以使用 DoubleStream。

转为对象流使用 boxed 方法// 生成0~100范围内的基本类型流，并转为包装对象流Stream integers = IntStream.range(0, 100).boxed();

并行流并行流就是将一个流的内容分成多个数据块，并用不同的线程分别处理每个不同数据块的流默认情况下，从有序集合（数组和列表）、范围、生成器和迭代产生的流，或者通过调用Stream.sorted 产生的流，都是有序的。

它们的结果是按照原来元素的顺序累积的，因此是完全可预知的如果运行相同的操作两次，将会得到完全相同的结果创建并行流parallel()：产生一个与当前流中元素相的并行流unordered()：产生一个与当前流中元素相 的无序流

parallel Stream()：用当前集合中的元素产生一个并行流乱序执行打印流中的每个元素由于并行流使用不同线程处理不同数据块，那么线程的执行先后顺序也变的不可知，所以打印的数字乱序List numbers = Arrays.asList(。

1, 2, 3, 4, 5, 6, 7, 8, 9);System.out.println("-------------stream---------------");numbers.stream().

forEach(out::print);numbers.stream().forEach(out::print);System.out.println("");System.out.println("----------parallelStream----------"

);numbers.parallelStream().forEach(out::print);numbers.parallelStream().forEach(out::print);-------------stream---------------123456789123456789----------parallelStream----------657893421643157289

注意：不要将所有的流都转换为并行流，只有在对已经位于内存中的数据执行大量计算操作时，才应该使用并行流为了让并行流正常工作，需要满足大量的条件：数据应该在内存中 必须等到数据到达是非常低效的流应该可以被高效地分成若干个子部分 由数组或平衡二叉树支撑的流都可以工作得很好，但是 Stream.iterate 返回的结果不行。

流操作的工作量应该具有较大的规模如果总工作负载并不是很大，那么搭建并行计算时所付出的代价就没有什么意义流操作不应该被阻塞文章来自https://www.cnblogs.com/jintangc/p/16380797.html。