Java中的Stream

Stream流的特点

 中间操作返回的是Stream类型，终结操作返回的是void

中间操作的这个Lazy指的是增加待处理操作，而不会真的处理（放队列里），集合中的数据并未实际改变，到终结操作的时候才会把这些放队列里的操作批量执行

每个操作都是对应一个函数式接口，例如

filter方法对应的是Predict这个函数式接口

forEach对应的是Consume这个函数式接口

具体哪个方法对应哪个接口可以到Stream这个类里去找

 

 获取流的演示

import java.util.*;
import java.util.stream.Stream;

public class GetStream {
    public static void main(String[] args) {
        //从list获取stream
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();
        //从set获取stream
        Set<String> set = new HashSet<>();
        Stream<String> stream1 = set.stream();
        
        Map<String, String> map = new HashMap<>();
        //获取map中的键，存储到一个Set集合里
        Set<String> keySet = map.keySet();
        Stream<String> stream2 = keySet.stream();
        //获取map里的值得集合，存储到一个Collection集合里
        Collection<String> values = map.values();
        Stream<String> stream3 = values.stream();
        //获取键值对
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream4 = entries.stream();

        //把数组转换为Stream流
        Integer[] arr = {1, 2, 3, 4, 5};
        String[] arr2 = {"a", "ab", "abc"};
        Stream<Integer> arr1 = Stream.of(arr);
        Stream<String> arr21 = Stream.of(arr2);
    }
}

一个Stream不管经历过何种操作都不能再次使用

public static void main(String[] args) {
    Stream<String> stream = Stream.of("张三丰", "张无忌", "张朝阳");
    Stream<String> stream1 = stream.filter(name -> name.startsWith("张"));
    //这样写是不行的，因为Stream属于管道流，只能被使用一次，不管怎么使用
    //第一个Stream流调用完毕，数据就会被转到下一个Stream上
    //而这时一个Stream流已经使用完毕，就会关闭了
    //所以第一个stream就不能再调用了，不然会出现java.lang.IllegalStateException: stream         has already been operated upon or closed
    //System.out.println(stream.count());
    stream1.forEach(name-> System.out.println(name));
}

concat

skip

 

 collect函数

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

public class Stream_collect {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<>();
        list.add("诸葛亮");
        list.add("刘备");
        list.add("关云长");
        list.add("张翼德");
        list.add("赵云");
        //得到名字为三个字的流
        Stream<String> stream = list.stream().filter(s -> s.length() == 3);
        //把使用Stream流操作完毕的数据收集到List集合中遍历
        List<String> stringList = stream.collect(Collectors.toList());
        for(String name : stringList) {
            System.out.println(name);
        }

        //创建一个Set集合
        Set<Integer> set = new HashSet<>();
        set.add(33);
        set.add(44);
        set.add(55);
        set.add(66);
        //得到大于35的流
        Stream<Integer> stream1 = set.stream().filter(age -> age > 35);
        Set<Integer> integerSet = stream1.collect(Collectors.toSet());
        for(int age : integerSet) {
            System.out.println(age);
        }

        //定义一个字符串数组，每一个字符串数组由姓名和年龄组成
        String[] strArray = {"刘备,50", "诸葛亮,40", "张飞,40","关羽,45"};
        Stream<String> stream2 = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) >= 45);
        Map<String, Integer> map = stream2.collect(Collectors.toMap(
                s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1])));
        Set<String> keySet = map.keySet();
        for(String key : keySet) {
            System.out.println(key);
        }
    }
}

对应运行结果如下：

诸葛亮
关云长
张翼德
66
55
44
关羽
刘备