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));
时间： 2024-11-28 23:08:57

java8--stream的相关文章

Java8 Stream API

Stream是Java8中,操作集合的一个重要特性. 从iteration到Stream操作 当你操作一个集合的时候,你通常的做法是迭代每一个元素,然后处理你想要的事情.举个例子: String contents = new String(Files.readAllBytes( Paths.get("alice.txt")), StandardCharsets.UTF_8); // 读取文件到字符串中 List<String> words = Arrays.asList(c

图解java8 stream 的几个转换方法

图片摘自:http://ifeve.com/stream/ 1.distinct 对于stream中包含的元素进行去重复操作(去重复依赖元素的equals方法) 2.filter 对于stream中包含的元素使用给定的过滤函数进行过滤操作 3.map 对于stream中包含的元素使用给定的转换函数进行转换操作.这个方法有三个变种方法:mapToInt.mapToLong.mapToDouble 4.flatmap 和map类似,不同的是其每个元素转换得到的是stream对象,会把子stream中

java8 stream流操作

Stream 在对流进行处理时,不同的流操作以级联的方式形成处理流水线.一个流水线由一个源(source),0 到多个中间操作(intermediate operation)和一个终结操作(terminal operation)完成. 源:源是流中元素的来源.Java 提供了很多内置的源,包括数组.集合.生成函数和 I/O 通道等. 中间操作:中间操作在一个流上进行操作,返回结果是一个新的流.这些操作是延迟执行的. 终结操作:终结操作遍历流来产生一个结果或是副作用.在一个流上执行终结操作之后,该

Java8 Stream流

Java8 Stream流 Java8关于map和flatMap的代码片段思考 Java8初体验(二)Stream语法详解 distinct() /* 返回一个流包含不同的元素(根据equals方法判断,null值并不会报空指针异常,会保留一个null). 对于有序的流保证稳定性,保留最先出现的元素,对于无序的流不保证稳定性. */ /** * Returns a stream consisting of the distinct elements (according to * {@link

【转】Java8 Stream 流详解

  当我第一次阅读 Java8 中的 Stream API 时,说实话,我非常困惑,因为它的名字听起来与 Java I0 框架中的 InputStream 和 OutputStream 非常类似.但是实际上,它们完全是不同的东西. Java8 Stream 使用的是函数式编程模式,如同它的名字一样,它可以被用来对集合进行链状流式的操作. 本文就将带着你如何使用 Java 8 不同类型的 Stream 操作.同时您还将了解流的处理顺序,以及不同顺序的流操作是如何影响运行时性能的. 我们还将学习终端

何用Java8 Stream API进行数据抽取与收集

上一篇中我们通过一个实例看到了Java8 Stream API 相较于传统的的Java 集合操作的简洁与优势,本篇我们依然借助于一个实际的例子来看看Java8 Stream API 如何抽取及收集数据. 备注:上一篇内容:如何用Java8 Stream API找到心仪的女朋友 ## 目标&背景 我们以"处理订单数据"为例,假设我们的应用是一个分布式应用,有"订单应用","物流应用","商品应用"等都是独立的服务.本次我

Java8 Stream初体验

如果你能说对下面这个语句的正确输出,那么恭喜你,这篇文章就不用看了~ List<Integer> nums = Arrays.asList(1,1,null,2,3,4,null,5,6,7,8,9,10); System.out.println("sum is:"+nums.stream().filter(num -> num != null).distinct(). mapToInt(num -> num * 2).peek(System.out::prin

用Java8 Stream和 Lambda表达式来解析文件的一个例子

最近我想从一个日志文件中提取出指定的数据,下面是日志的一部分: 2015-01-06 11:33:03 b.s.d.task [INFO] Emitting: eVentToRequestsBolt __ack_ack [-6722594615019711369 -1335723027906100557] 2 2015-01-06 11:33:03 c.s.p.d.PackagesProvider [INFO] ===---> Loaded package com.foo.bar 3 2015-

java8 stream ,filter 等功能代替for循环

直接上代码,比较实在. 对象A public Class A{ private Long id; private String userName; ..... ....省略get和set方法 } 在List<A>中,查找userName为hanmeimei的对象A. 在java8中,我们可以这么玩 1,查找集合中的第一个对象. Optional<A> firstA= AList.stream() .filter(a -> "hanmeimei".equal

Java8 stream学习

第一个Stream Demo IDEA里面写Stream有个坑 虽然java文件中没错,但是但编译的时候还是报错了, Information:java: javacTask: 源发行版 1.8 需要目标发行版 1.8 解决方法是:perferences -> Build,Execution, Deployment -> Compiler -> Java Compiler 设置相应Module的 bytecode version即可 public class StreamDemo { pu