一、Stream介绍

Stream是用于集合迭代器的增强，使之能够完成更高效的聚合操作，或者大批量数据操作。

二、Stream的API

2.1 获取Stream流

public class Demo01GetStream {
    public static void main(String[] args) {
   // 1.Collection和Array通过stream()【串行】或者parallelStream()【并行】。 
        //把集合转换为Stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();
        Map<String,String> map = new HashMap<>();
        //获取键,存储到一个Set集合中
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();
        //获取值,存储到一个Collection集合中
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream()；
        //获取键值对(键与值的映射关系 entrySet)
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();
    //2.Stream接口的静态方法of可以获取数组对应的流。
        //把数组转换为Stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        //可变参数可以传递数组
        Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);
        String[] arr2 = {"a","bb","ccc"};
        Stream<String> stream8 = Stream.of(arr2);
   
    //3.Stream.iterate() 、Stream.generate()创建无限流。
        //迭代
        Stream<Integer> stream9 = Stream.iterate(0,(x) -> x+2);
        stream9.limit(10).forEach(System.out::println);
         //生成
       Stream<Integer> stream10 = Stream.generate(() -> Math.random());
       stream10.limit(10).forEach(System.out::println);

    }
}

2.2 流的转换

filter方法：过滤流中数据

//需求：过滤integerList中小于50的，并生成新的List<Integer>
List<Integer> integerList =  new ArrayList();
 integerList.add(15);
 integerList.add(32);
 integerList.add(5);
 integerList.add(232);
 integerList.add(56);
//Lamdba写法
List<Integer> after2 = integerList.stream().filter(i->i>50)
                .collect(Collectors.toList());
System.out.println(after2);

map方法：类型转换

// 需求：将List<Integer>类型转换成List<String>类型
List<Integer> integerList =  new ArrayList();
integerList.add(15);
integerList.add(32);
integerList.add(5);
integerList.add(232);
integerList.add(56);
//lamdba表达式写法
List<String> afterString2 = integerList.stream().map(i->String.valueOf(i))
.collect(Collectors.toList());
System.out.println(afterString2.toString());

flatMap方法：类型转换

//需求：从testMap中取出oneList+twoList的List<Integer>
List<Integer>  oneList =  new ArrayList();
List<Integer>  twoList =  new ArrayList();
oneList.add(34);
oneList.add(23);
twoList.add(29);
twoList.add(48);
Map<String,List<Integer>> testMap = new HashMap();
testMap.put("1",oneList);
testMap.put("2",twoList);
//Lamdba写法
List<Integer> testList1 =  testMap.values().stream().flatMap(number->number.stream()).collect(Collectors.toList());
System.out.println(testList1.toString());

2.3 聚合操作(终止)

max方法和min方法

List<Integer> hearList = Lists.newArrayList();
hearList.add(15);
hearList.add(32);
hearList.add(94);
Integer maxItem = hearList.stream().max(Integer::compareTo).get();
Integer minItem = hearList.stream().min(Integer::compareTo).get();
System.out.println("max:"+maxItem+"，min:"+minItem);

reduce方法

List<Integer> hearList = Lists.newArrayList();
hearList.add(15);
hearList.add(56);
hearList.add(29);
hearList.add(104);
//求和
Integer sum = hearList.stream().reduce((x,y)->x+y).get();
System.out.println("sum:"+sum);
//简化一下，求和
sum = hearList.stream().reduce(Integer::sum).get();
System.out.println("sum:"+sum);
//含有初始标识的，求和
sum = hearList.stream().reduce(0,(x,y)->x+y);
System.out.println("sum:"+sum);
//对元素的长度进行求和( (total,y)->total+y.toString().length()，类似于一个累加器，会被重复调用)
sum = hearList.stream().reduce(0,(total,y)->total+y.toString().length(),(total1,total2)->total1+total2);
System.out.println("sum:"+sum);
//简化一下，对元素长度进行求和。
sum = hearList.stream().map(Objects::toString).mapToInt(String::length).sum();
System.out.println("sum:"+sum);

其他常见聚合API：findFirst、findAny、anyMatch、allMatch、noneMatch

2.4 收集结果(终止)

当处理完流之后，通常是想查看一下结果，而不是将他们聚合为一个值。Collectorts类为我们提供了常用的收集类的各个工厂方法。
收集到集合

//收集到一个List
List<Integer> thereList = hereList.stream().collect(Collectors.toList());
//收集到Set中
Set<Integer> thereSet = hereList.stream().collect(Collectors.toSet());
//收集到Set时，控制Set的类型
TreeSet<Integer> treeSet = hereList.stream().collect(Collectors.toCollection(TreeSet::new));
//收集到map
Map<Integer,Integer> hwMap = roomList.stream().collect(Collectors.toMap(Room::getHigh, Room::getWidth));

拼接

//将字流中的字符串连接并收集起来
String resultString = stringList.stream().collect(Collectors.joining());
//在将流中的字符串连接并收集起来时，想在元素中介添加分隔符，传递个joining方法即可
String resultString = stringList.stream().collect(Collectors.joining(","));
//当流中的元素不是字符串时，需要先将流转成字符串流再进行拼接。
String hereResultString = hereList.stream().map(String::valueOf).collect(Collectors.joining(","));

2.5 并行流

我们使在处理集合数据量较大的时候才能体现出并行流的优势，并且目的是为了在保证线程安全的情况下，提升效率，利用多核CPU的资源。并行流就是把一个内容分成多个数据块，并用不同的线程分成多个数据块，并用不同的线程分别处理每个数据块的流,串行流则相反。

public static void main(String[] args) {
    Random random = new Random();

    //非并行流
    Stream.generate(() -> random.nextInt(1000))
            .limit(10)
            .forEach(x -> System.out.println(x + ": " + Thread.currentThread().getName()));

    //并行流
    Stream.generate(() -> random.nextInt(1000))
            .limit(1000)
            //转换成并行流
            .parallel()
            .forEach(x -> System.out.println(x + ": " + Thread.currentThread().getName()));
}

ForkJoinPool