java Stream 流

一、获取

1、针对Collection

// Stream<E> stream = collection对象.stream();
// list是 collection对象， 是 ArrayList<Person>对象
Stream<Person> stream = list.stream();

2、针对数组

//Stream<E> stream =  Stream.of(... values); ...values，不定参数

Stream<String> stream1 = Stream.of("王也", "王爷", "金莲", "瓶儿", "好滋味");

二、常用方法

1、forEach遍历，注意是 终结方法， 使用完后Stream流不能用

package com.wt.lambda;

import java.util.function.Consumer;
import java.util.stream.Stream;

public class Demon01 {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("王也", "王爷", "金莲", "瓶儿", "好滋味");

        stream1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                if (s.startsWith("王")){
                    System.out.println(s);
                }
            }
        });

        // Lambda 简写
        stream1.forEach( s -> {
                if (s.startsWith("王")){
                    System.out.println(s);
                }
            }
        );
    }
}

2、count方法，计算元素数列，也是终结方法，有返回值

package com.wt.lambda;

import java.util.stream.Stream;

public class Demon02 {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("王波", "西门", "东方", "南宫");
        long count = stream.count();
        System.out.println(count);
    }
}

3、filter 过滤，有返回值

package com.wt.lambda;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demon02 {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("王波", "西门", "东方", "南宫", "王一", "王大波");
       /* // 筛选
        stream.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("王");
            }
            // 遍历
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        // Lambda
        stream.filter( s ->s.startsWith("王")).forEach( s -> System.out.println(s));
    }
}

4、limit(n)， 获取前n个元素的Stream，有返回值

package com.wt.lambda;

import java.util.stream.Stream;

public class Demon03 {
    public static void main(String[] args) {
        Stream<Object> stream = Stream.of("王波", "西门", "东方", "南宫", "王一", "王大波");
        stream.limit(4).forEach(item-> System.out.println(item));
    }
}

5、skip(n)，跳过n个元素的Stream，有返回值

package com.wt.lambda;

import java.util.stream.Stream;

public class Demon03 {
    public static void main(String[] args) {
        Stream<Object> stream = Stream.of("王波", "西门", "东方", "南宫", "王一", "王大波");
        stream.skip(3).forEach(s-> System.out.println(s));
    }
}

6、concat() ，两个Stream对象相加，有返回值

语法

Stream<Object> concat = Stream.concat(stream, stream1);

案例

package com.wt.lambda;

import java.util.stream.Stream;

public class Demon03 {
    public static void main(String[] args) {
        Stream<Object> stream = Stream.of("王波", "西门", "东方", "南宫", "王一", "王大波");
        Stream<String> stream1 = Stream.of("喜洋洋", "美羊羊", "懒洋洋");
        Stream<Object> concat = Stream.concat(stream, stream1);
        concat.forEach(s-> System.out.println(s));
    }
}

7、collect()， 将Stream流变成集合(collection)，有返回值

package com.wt.lambda;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demon03 {
    public static void main(String[] args) {
        Stream<Object> stream = Stream.of("王波", "西门", "东方", "南宫", "王一", "王大波");
        List<Object> list = stream.collect(Collectors.toList());
        System.out.println(list);
    }
}

8、distinct， 去重(依据hashCode和equals)，有返回值

案例一

package com.wt.lambda;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demon03 {
    public static void main(String[] args) {
        Stream<Object> stream = Stream.of("王波", "西门", "东方", "南宫", "王一", "王大波","西门");
        stream.distinct().forEach(s-> System.out.println(s));
    }
}

案例二

package com.wt.lambda;

import java.util.ArrayList;
import java.util.Collections;


public class Demon03 {
    public static void main(String[] args) {
        ArrayList<Person> people = new ArrayList<>();
        Collections.addAll(people, new Person("小心", 10), new Person("小葵", 2), new Person("小心", 10), new Person("小文", 14));
        // collection对象变成 Stream
        people.stream().distinct().forEach(person -> System.out.println(person));
    }
}

9、map() ，转换流中的数据类型，有返回值

package com.wt.lambda;

import java.util.function.Function;
import java.util.stream.Stream;

public class Demon04 {
    public static void main(String[] args) {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
        /*integerStream.map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return integer+"";
            }
        }).forEach(s-> System.out.println(s));*/

        // Lambda
        integerStream.map(integer -> integer+"").forEach(s-> System.out.println(s));

    }
}