java8--stream

*:first-child {
margin-top: 0 !important;
}

.markdown-body>*:last-child {
margin-bottom: 0 !important;
}

.markdown-body .headeranchor-link {
position: absolute;
top: 0;
bottom: 0;
left: 0;
display: block;
padding-right: 6px;
padding-left: 30px;
margin-left: -30px;
}

.markdown-body .headeranchor-link:focus {
outline: none;
}

.markdown-body h1,
.markdown-body h2,
.markdown-body h3,
.markdown-body h4,
.markdown-body h5,
.markdown-body h6 {
position: relative;
margin-top: 1em;
margin-bottom: 16px;
font-weight: bold;
line-height: 1.4;
}

.markdown-body h1 .headeranchor,
.markdown-body h2 .headeranchor,
.markdown-body h3 .headeranchor,
.markdown-body h4 .headeranchor,
.markdown-body h5 .headeranchor,
.markdown-body h6 .headeranchor {
display: none;
color: #000;
vertical-align: middle;
}

.markdown-body h1:hover .headeranchor-link,
.markdown-body h2:hover .headeranchor-link,
.markdown-body h3:hover .headeranchor-link,
.markdown-body h4:hover .headeranchor-link,
.markdown-body h5:hover .headeranchor-link,
.markdown-body h6:hover .headeranchor-link {
height: 1em;
padding-left: 8px;
margin-left: -30px;
line-height: 1;
text-decoration: none;
}

.markdown-body h1:hover .headeranchor-link .headeranchor,
.markdown-body h2:hover .headeranchor-link .headeranchor,
.markdown-body h3:hover .headeranchor-link .headeranchor,
.markdown-body h4:hover .headeranchor-link .headeranchor,
.markdown-body h5:hover .headeranchor-link .headeranchor,
.markdown-body h6:hover .headeranchor-link .headeranchor {
display: inline-block;
}

.markdown-body h1 {
padding-bottom: 0.3em;
font-size: 2.25em;
line-height: 1.2;
border-bottom: 1px solid #eee;
}

.markdown-body h2 {
padding-bottom: 0.3em;
font-size: 1.75em;
line-height: 1.225;
border-bottom: 1px solid #eee;
}

.markdown-body h3 {
font-size: 1.5em;
line-height: 1.43;
}

.markdown-body h4 {
font-size: 1.25em;
}

.markdown-body h5 {
font-size: 1em;
}

.markdown-body h6 {
font-size: 1em;
color: #777;
}

.markdown-body p,
.markdown-body blockquote,
.markdown-body ul,
.markdown-body ol,
.markdown-body dl,
.markdown-body table,
.markdown-body pre,
.markdown-body .admonition {
margin-top: 0;
margin-bottom: 16px;
}

.markdown-body hr {
height: 4px;
padding: 0;
margin: 16px 0;
background-color: #e7e7e7;
border: 0 none;
}

.markdown-body ul,
.markdown-body ol {
padding-left: 2em;
}

.markdown-body ul ul,
.markdown-body ul ol,
.markdown-body ol ol,
.markdown-body ol ul {
margin-top: 0;
margin-bottom: 0;
}

.markdown-body li>p {
margin-top: 16px;
}

.markdown-body dl {
padding: 0;
}

.markdown-body dl dt {
padding: 0;
margin-top: 16px;
font-size: 1em;
font-style: italic;
font-weight: bold;
}

.markdown-body dl dd {
padding: 0 16px;
margin-bottom: 16px;
}

.markdown-body blockquote {
padding: 0 15px;
color: #777;
border-left: 4px solid #ddd;
}

.markdown-body blockquote>:first-child {
margin-top: 0;
}

.markdown-body blockquote>:last-child {
margin-bottom: 0;
}

.markdown-body table {
display: block;
width: 100%;
overflow: auto;
word-break: normal;
word-break: keep-all;
}

.markdown-body table th {
font-weight: bold;
}

.markdown-body table th,
.markdown-body table td {
padding: 6px 13px;
border: 1px solid #ddd;
}

.markdown-body table tr {
background-color: #fff;
border-top: 1px solid #ccc;
}

.markdown-body table tr:nth-child(2n) {
background-color: #f8f8f8;
}

.markdown-body img {
max-width: 100%;
-moz-box-sizing: border-box;
box-sizing: border-box;
}

.markdown-body code,
.markdown-body samp {
padding: 0;
padding-top: 0.2em;
padding-bottom: 0.2em;
margin: 0;
font-size: 85%;
background-color: rgba(0,0,0,0.04);
border-radius: 3px;
}

.markdown-body code:before,
.markdown-body code:after {
letter-spacing: -0.2em;
content: "\00a0";
}

.markdown-body pre>code {
padding: 0;
margin: 0;
font-size: 100%;
word-break: normal;
white-space: pre;
background: transparent;
border: 0;
}

.markdown-body .codehilite {
margin-bottom: 16px;
}

.markdown-body .codehilite pre,
.markdown-body pre {
padding: 16px;
overflow: auto;
font-size: 85%;
line-height: 1.45;
background-color: #f7f7f7;
border-radius: 3px;
}

.markdown-body .codehilite pre {
margin-bottom: 0;
word-break: normal;
}

.markdown-body pre {
word-wrap: normal;
}

.markdown-body pre code {
display: inline;
max-width: initial;
padding: 0;
margin: 0;
overflow: initial;
line-height: inherit;
word-wrap: normal;
background-color: transparent;
border: 0;
}

.markdown-body pre code:before,
.markdown-body pre code:after {
content: normal;
}

/* Admonition */
.markdown-body .admonition {
-webkit-border-radius: 3px;
-moz-border-radius: 3px;
position: relative;
border-radius: 3px;
border: 1px solid #e0e0e0;
border-left: 6px solid #333;
padding: 10px 10px 10px 30px;
}

.markdown-body .admonition table {
color: #333;
}

.markdown-body .admonition p {
padding: 0;
}

.markdown-body .admonition-title {
font-weight: bold;
margin: 0;
}

.markdown-body .admonition>.admonition-title {
color: #333;
}

.markdown-body .attention>.admonition-title {
color: #a6d796;
}

.markdown-body .caution>.admonition-title {
color: #d7a796;
}

.markdown-body .hint>.admonition-title {
color: #96c6d7;
}

.markdown-body .danger>.admonition-title {
color: #c25f77;
}

.markdown-body .question>.admonition-title {
color: #96a6d7;
}

.markdown-body .note>.admonition-title {
color: #d7c896;
}

.markdown-body .admonition:before,
.markdown-body .attention:before,
.markdown-body .caution:before,
.markdown-body .hint:before,
.markdown-body .danger:before,
.markdown-body .question:before,
.markdown-body .note:before {
font: normal normal 16px fontawesome-mini;
-moz-osx-font-smoothing: grayscale;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
line-height: 1.5;
color: #333;
position: absolute;
left: 0;
top: 0;
padding-top: 10px;
padding-left: 10px;
}

.markdown-body .admonition:before {
content: "\f056\00a0";
color: 333;
}

.markdown-body .attention:before {
content: "\f058\00a0";
color: #a6d796;
}

.markdown-body .caution:before {
content: "\f06a\00a0";
color: #d7a796;
}

.markdown-body .hint:before {
content: "\f05a\00a0";
color: #96c6d7;
}

.markdown-body .danger:before {
content: "\f057\00a0";
color: #c25f77;
}

.markdown-body .question:before {
content: "\f059\00a0";
color: #96a6d7;
}

.markdown-body .note:before {
content: "\f040\00a0";
color: #d7c896;
}

.markdown-body .admonition::after {
content: normal;
}

.markdown-body .attention {
border-left: 6px solid #a6d796;
}

.markdown-body .caution {
border-left: 6px solid #d7a796;
}

.markdown-body .hint {
border-left: 6px solid #96c6d7;
}

.markdown-body .danger {
border-left: 6px solid #c25f77;
}

.markdown-body .question {
border-left: 6px solid #96a6d7;
}

.markdown-body .note {
border-left: 6px solid #d7c896;
}

.markdown-body .admonition>*:first-child {
margin-top: 0 !important;
}

.markdown-body .admonition>*:last-child {
margin-bottom: 0 !important;
}

/* progress bar*/
.markdown-body .progress {
display: block;
width: 300px;
margin: 10px 0;
height: 24px;
-webkit-border-radius: 3px;
-moz-border-radius: 3px;
border-radius: 3px;
background-color: #ededed;
position: relative;
box-shadow: inset -1px 1px 3px rgba(0, 0, 0, .1);
}

.markdown-body .progress-label {
position: absolute;
text-align: center;
font-weight: bold;
width: 100%; margin: 0;
line-height: 24px;
color: #333;
text-shadow: 1px 1px 0 #fefefe, -1px -1px 0 #fefefe, -1px 1px 0 #fefefe, 1px -1px 0 #fefefe, 0 1px 0 #fefefe, 0 -1px 0 #fefefe, 1px 0 0 #fefefe, -1px 0 0 #fefefe, 1px 1px 2px #000;
-webkit-font-smoothing: antialiased !important;
white-space: nowrap;
overflow: hidden;
}

.markdown-body .progress-bar {
height: 24px;
float: left;
-webkit-border-radius: 3px;
-moz-border-radius: 3px;
border-radius: 3px;
background-color: #96c6d7;
box-shadow: inset 0 1px 0 rgba(255, 255, 255, .5), inset 0 -1px 0 rgba(0, 0, 0, .1);
background-size: 30px 30px;
background-image: -webkit-linear-gradient(
135deg, rgba(255, 255, 255, .4) 27%,
transparent 27%,
transparent 52%, rgba(255, 255, 255, .4) 52%,
rgba(255, 255, 255, .4) 77%,
transparent 77%, transparent
);
background-image: -moz-linear-gradient(
135deg,
rgba(255, 255, 255, .4) 27%, transparent 27%,
transparent 52%, rgba(255, 255, 255, .4) 52%,
rgba(255, 255, 255, .4) 77%, transparent 77%,
transparent
);
background-image: -ms-linear-gradient(
135deg,
rgba(255, 255, 255, .4) 27%, transparent 27%,
transparent 52%, rgba(255, 255, 255, .4) 52%,
rgba(255, 255, 255, .4) 77%, transparent 77%,
transparent
);
background-image: -o-linear-gradient(
135deg,
rgba(255, 255, 255, .4) 27%, transparent 27%,
transparent 52%, rgba(255, 255, 255, .4) 52%,
rgba(255, 255, 255, .4) 77%, transparent 77%,
transparent
);
background-image: linear-gradient(
135deg,
rgba(255, 255, 255, .4) 27%, transparent 27%,
transparent 52%, rgba(255, 255, 255, .4) 52%,
rgba(255, 255, 255, .4) 77%, transparent 77%,
transparent
);
}

.markdown-body .progress-100plus .progress-bar {
background-color: #a6d796;
}

.markdown-body .progress-80plus .progress-bar {
background-color: #c6d796;
}

.markdown-body .progress-60plus .progress-bar {
background-color: #d7c896;
}

.markdown-body .progress-40plus .progress-bar {
background-color: #d7a796;
}

.markdown-body .progress-20plus .progress-bar {
background-color: #d796a6;
}

.markdown-body .progress-0plus .progress-bar {
background-color: #c25f77;
}

.markdown-body .candystripe-animate .progress-bar{
-webkit-animation: animate-stripes 3s linear infinite;
-moz-animation: animate-stripes 3s linear infinite;
animation: animate-stripes 3s linear infinite;
}

@-webkit-keyframes animate-stripes {
0% {
background-position: 0 0;
}

100% {
background-position: 60px 0;
}
}

@-moz-keyframes animate-stripes {
0% {
background-position: 0 0;
}

100% {
background-position: 60px 0;
}
}

@keyframes animate-stripes {
0% {
background-position: 0 0;
}

100% {
background-position: 60px 0;
}
}

.markdown-body .gloss .progress-bar {
box-shadow:
inset 0 4px 12px rgba(255, 255, 255, .7),
inset 0 -12px 0 rgba(0, 0, 0, .05);
}

/* Multimarkdown Critic Blocks */
.markdown-body .critic_mark {
background: #ff0;
}

.markdown-body .critic_delete {
color: #c82829;
text-decoration: line-through;
}

.markdown-body .critic_insert {
color: #718c00 ;
text-decoration: underline;
}

.markdown-body .critic_comment {
color: #8e908c;
font-style: italic;
}

.markdown-body .headeranchor {
font: normal normal 16px octicons-anchor;
line-height: 1;
display: inline-block;
text-decoration: none;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
}

.headeranchor:before {
content: '\f05c';
}

.markdown-body .task-list-item {
list-style-type: none;
}

.markdown-body .task-list-item+.task-list-item {
margin-top: 3px;
}

.markdown-body .task-list-item input {
margin: 0 4px 0.25em -20px;
vertical-align: middle;
}

/* Media */
@media only screen and (min-width: 480px) {
.markdown-body {
font-size:14px;
}
}

@media only screen and (min-width: 768px) {
.markdown-body {
font-size:16px;
}
}

@media print {
.markdown-body * {
background: transparent !important;
color: black !important;
filter:none !important;
-ms-filter: none !important;
}

.markdown-body {
font-size:12pt;
max-width:100%;
outline:none;
border: 0;
}

.markdown-body a,
.markdown-body a:visited {
text-decoration: underline;
}

.markdown-body .headeranchor-link {
display: none;
}

.markdown-body a[href]:after {
content: " (" attr(href) ")";
}

.markdown-body abbr[title]:after {
content: " (" attr(title) ")";
}

.markdown-body .ir a:after,
.markdown-body a[href^="javascript:"]:after,
.markdown-body a[href^="#"]:after {
content: "";
}

.markdown-body pre {
white-space: pre;
white-space: pre-wrap;
word-wrap: break-word;
}

.markdown-body pre,
.markdown-body blockquote {
border: 1px solid #999;
padding-right: 1em;
page-break-inside: avoid;
}

.markdown-body .progress,
.markdown-body .progress-bar {
-moz-box-shadow: none;
-webkit-box-shadow: none;
box-shadow: none;
}

.markdown-body .progress {
border: 1px solid #ddd;
}

.markdown-body .progress-bar {
height: 22px;
border-right: 1px solid #ddd;
}

.markdown-body tr,
.markdown-body img {
page-break-inside: avoid;
}

.markdown-body img {
max-width: 100% !important;
}

.markdown-body p,
.markdown-body h2,
.markdown-body h3 {
orphans: 3;
widows: 3;
}

.markdown-body h2,
.markdown-body h3 {
page-break-after: avoid;
}
}
-->

java8-stream

Stream API

• Stream API
  • 创建Stream
  • filter、map和flatMap方法
  • limit()、skip()和concat():提取子流和组合流
  • distinct()、Sorted():有状态转换
  • 聚合方法–终止流操作
  • Optional类型
  • 原始流类型
  • 并行流

Stream 是java8中处理集合的关键抽象概念，他可以制定你希望对集合进行的操作，但是将执行操作的时间交给具体实现来决定。

要点

• 可以从集合、数组、生成器或者迭代器中创建Stream。
• 使用filter来选择元素，使用map来改变元素。
• 其他改变Stream的操作包括limit、distinct、sorted。
• 要从Stream中获得结果，请使用reduction操作符，例如count、max、min、findFirst或findAny、其中一些方法会返回一个Optional值。
• Optional类型的目的是为了安全的替代使用null值。要想安全的使用，需要借助ifPresent和orElse方法。
• 可以收集集合、数组、字符串或map中的Stream结果。
• Collectors类的groupingBy和partitioningBy允许对Stream中的内容分组，并获取每个组的结果。
• java8对原始类型int、long和double提供了专门的Stream。
• 当使用并行Stream时，请确保不带有副作用，并考虑放弃排序约束。

---

Stream Example:

    @Test//*不使用Stream的方法*
    public void testCount(){
        List<String> words = getWords();
        int count = 0;
        for (String w: words) {
            if(w.length()>10)count++;
        }
        System.out.println(count);
    }
    @Test//*使用Stream*
    public void testStream(){
        List<String> words = getWords();
        long count=0;
        count =words.stream().filter(w->w.length()>10).count();
        System.out.println(count);
    }
    public List<String> getWords(){
        List<String> words = new ArrayList<String>();
        for (int i = 0; i < 20; i++) {
            words.add("aaabbbccc"+i);
        }
        return words;
    }

可以看出来Stream给我们带来了很大的方便性和可读性
当使用Stream时，通过三个阶段来建立一个操作流水线
1. 创建一个Stream
2. 在一个或多个步骤中，制定将初始Stream转换为另一个Stream的中间操作。
3. 使用一个终止操作来产生一个结果。该操作会强制他之前的延迟操作立即执行。在这之后，该Stream就不会在被使用了。

创建Stream

java8在Collection接口中添加了stream方法，可以将任何一个集合转化为一个Stream。

    Stream<String> words = Stream.of(contents.split(","));
    //split方法返回一个String[]数组
    //of方法接受可变长度的参数,因此可以构造一个含有任何个参数的Stream
    Stream<String> words = Stream.of("hello","world","java8","lambda");

使用Arrays.stream(array,from,to)方法将数组的一部分转化为Stream
如果要创建一个不含任何元素的Stream，可以使用静态的Stream.empty方法：

Stream<String> words = Stream.empty();

Stream接口有两个用来创建无限Stream的静态方法。generate方法接受一个无参函数，

    @Test
    public void testInit(){
        Stream<String> echos = Stream.generate(()->"Echo");
        Stream<Double> randoms= Stream.generate(Math::random);
    }

Java8中添加了许多能够产生Stream的方法。比如 Pattern类添加了一个splitAsStream方法。

Stream<String> words = Pattern.complie(",").splitAsStream(contents);

filter、map和flatMap方法

• filter方法的参数是一个Predicate对象–即一个从T到boolean的函数。

  Stream<String> words = getWords().stream().filter(w->w.length()>10);
  

• 当对一个流中的值进行某种转换时，使用map方法。

  //将单词转换为大写
  Stream<String> words = getWords().stream().map(String::toUpperCase);
  //获得单词的第一个字母
  Stream<Character> wordsFirstChar = getWords().stream().map(s->s.charAt(0));
  

• flatMap

      @Test
      public void testMapAndFlatMap(){
          Stream<Stream<Character>> chars = getWords().stream().map(w->getCharacter(w));
          //这里可以用flatMap
          //flatMap 会对每个对象调用getCharacter()方法，并展开结果
          Stream<Character> charss=getWords().stream().flatMap(w->getCharacter(w));
      }
      public Stream<Character> getCharacter(String s){
          List<Character> chars = new ArrayList<Character>();
          for (char c: s.toCharArray()) {
              chars.add(c);
          }
          return chars.stream();
      }
  

limit()、skip()和concat():提取子流和组合流

• Stream.limit(n)会返回一个包含n个元素的新流如果原始流长度小于n，则返回原始流

  //返回1个具有100个随机数的流
  Stream<Double> randoms100 = Stream.generate(Math::random).limit(100);
  

• Stream.skip(n)会跳过n个元素。

  //跳过第一个单词组成流
  Stream<String> wordsWithoutFirst = getWords().stream().skip(1);
  System.out.println(wordsWithoutFirst.count());//打印为 19  略过了第一个元素
  

• Stream.concat() 静态方法。合并两个流。
  合并流的第一个应该为无限状态

      Stream<String> total = Stream.concat(getWords().stream().skip(10), getWords().stream());
      System.out.println(total.count());
  

distinct()、Sorted():有状态转换

上面的流转换都是无状态的。也就是获得的结果不依赖前面的元素。java8也提供了有状态的转换。例如distinct()
distinct()方法需要记录已存储的单词。然后判断重复及是否添加

    Stream<String> unique = Arrays.asList("todo","todo","todo","today").stream().distinct();
    System.out.println(unique.count());//2

sorted方法排序必须遍历整个流。并在产生任何元素之前对他进行排序。

    Stream<String> sortWords = getWords().stream().sorted(Comparator.comparing(String::length).reversed());

Collections.sort方法会对原有集合进行排序，Stream.sorted方法会返回一个新的已排序的流;

聚合方法–终止流操作

聚合方法都是终止操作。当一个流应用了终止操作以后，他就不能在进行其他操作了。
聚合方法主要有：count(),max(),min(),findFirst,findAny,allMatch,noneMatch等

    //找到排序最大的单词 min同理
    Optional<String> max = getWords().stream().max(String::compareToIgnoreCase);
    if(max.isPresent()){
        System.out.println(max.get());
    }
    //找到所有的以a开头的单词
    Optional<String> words = getWords().stream().filter(s->s.startsWith("a")).findAny();
    //找到所有的以a开头的第一个单词
    Optional<String> wordFirst = getWords().stream().filter(s->s.startsWith("a")).findFirst();

allMatch,noneMatch分别表示所有元素和没有元素匹配predicate返回true。

Optional类型

• Optional对象或者是对一个T类型对象的封装，或表示不是任何对象。他比一般指向T类型的引用更安全，因为他不会返回null–但也是在正确的使用前提下。
  如果存在被封装的对象，那么 get方法会返回该对象，否则会抛出一个NoSuchElementException.所以，可以用isPresend()来判断一下。

      Optional<String> max = getWords().stream().max(String::compareToIgnoreCase);
          if(max.isPresent()){
              //do something
          }
  

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

  String result = max.orElse("");
  

  如果没有值则用“”替代。
  此外orElse还有两个方法
  orElseGet(Lambda):可以调用代码计算值
  orElseThrow(Exception):抛出异常

• 创建optional
  利用Optional的静态方法可以创建对象，比如Optional.of(result)或者Optional.empty();
  ofNullable(obj)方法会跟据obj的值来进行创建optional，如果obj==null，那么这个方法间接等于Optional.empty(),
  如果obj！=null 那么 间接等于Optional.of(obj);
  +收集结果
  可以通过iterator方法生成一个迭代器，用来访问结果的元素，或者使用stream.toArray()，他会返回一个Object[]数组。如果想获得具体类型的。
  可以把类型传递给数组的构造函数

  String[] result = words.toArray(String[]::new);
  

  如果要把结果收集到一个HashSet中，如果这个过程是并行的，那么不能将元素放到一个单独的Hashset中，因为HashSet不是线程安全的。所以要使用collect方法，他接受三个参数
  1. 一个能创建目标类型实例的方法，例如hashset的构造函数。
  2. 一个江元素添加到目标中的方法，例如一个add方法。
  3. 一个将两个对象整合到一起的方法，例如addALl方法。

  HashSet<String> result = stream.collect(HashSet::new,HashSet::add,HashSet::addAll);
  

  在实际中，通常不需要这么做，因为Collector借口已经提供了这三个方法，

  List<String> result = getWords().stream().collect(Collectors.toList());
  List<String> result = getWords().stream().collect(Collectors.toSet());
  TreeSet<String> result = stream.collect(Collectors.toCollection(TreeSet::new));
  

  Collectors还有许多方法，可以自己去看一下api

原始流类型

主要有IntStream、DoubleStream、LongStream等。
IntStream:short、char、byte、boolean
DoubleStream：float
LongStream:long

IntStream intStream = IntStream.of(1,2,3,4);
intStream = Arrays.stream(value,from,to);  //value 为一个int[]数组

• 原始流和对象流转换

当有一个对象流的时候，可以通过mapToInt、mapToLong或者mapToDouble方法将他们转换为一个原始流。

Stream<String> words = getWords();
IntStream length = words.mapToInt(String::length);

将一个原始流转换为对象流时，可以使用boxed方法。

Stream<Integer> integers = IntStream.range(0,100).boxed();

并行流

默认情况下，流操作会创建一个串行流,方法Collection.parallelStream()除外。parallel方法可以将任意一个串行流变为一个并行流。

Stream<String> words = getWords().stream().parallel();

只要在终止方法执行时，流处于并行模式，那么所有的延迟执行的流操作就都会被并行执行。
当并行运行流时，他应返回与串行运行时相同的结果。这些操作都是无状态的，因此可以以任意顺序被执行
下面是一个反例，用来提示不应该这么做，假设你需要绩一个字符串流中所有短单词的总数：

        int[] shortWords = new int[11];
        Stream<String> words = Arrays.asList("java","c++","javac","eclipse","tomcat","helloworld").stream();
        words.parallel().forEach(s->{if(s.length()<5)shortWords[s.length()]++;});
        System.out.println(Arrays.toString(shortWords));

传递给foreach的函数会在多个线程中并发运行，来更新一个共享数组，这是一个经典的条件竞争。如果多运行几次，很有可能会得到不同的总数，并且没有一个是对的。
使用并行流操作的函数都应该是线程安全的。

当执行一个流(串行和并行)操作时，并不会修改流底层的集合，流不会收集他自己的数据–这些数据总是存在另一个集合中。如果想要修改原有的集合，那么就无法定义流操作的输出。

下面这么做是可以的。

List<String> words = ...;
Stream<String> wordStream=words.stream();
words.add("end");
long n  = wordStream.distinct().count();

下面是不可以的，因为干扰了原集合

Stream<String> wordStream = words.stream();
wordStream.forEach(s->if(s.length<12)words.remove(s));