Streaming API

概述：

Stream是jdk8增加的一个接口，该接口提供了一些对容器数据进行操作的规则，有了这些规则就可以不通过遍历容器就可以以完成对相关数据的操作处理。

理解：

Stream可以理解为像生产流水线，操作只能往前走不能回退，经过一道工序操作的数据就会发生变化上一道工序的对象就消失不可再次使用

作用：

不用遍历容器下对容器数据进行操作

注意：

Stream虽然可以操作数据但是本身不能够存储任何数据

Steam对象的获取：

1、Collection的Stream获取

集合中提供了方法：

stream()：

返回一个集合对应的Stream流对象

2、Map的Stream的获取

不能直接获取Stream对象，只能变为单列集合再去获取对应的stream对象

keySet：

获取所有key的set集合

entrySet：

获取所有键值对对象的set集合

values：

获取所有value的collection集合

单列集合调用stream方法获取对应的stream对象

3、数组的Stream获取：

使用Stream接口的静态方法：of(T t)

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.stream.Stream;
public class StreamDemo {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<String>();
        //获取stream对象
        Stream<String> stream = list.stream();
        //创建双列集合
        HashMap<Integer, String> map = new HashMap<Integer, String>();
        //添加集合数据
        map.put(1, "张三");
        map.put(2, "李四");
        map.put(3, "王五");
        //获取所有key的set集合
        Set<Integer> ks = map.keySet();
        //获取所有键值对对象的set集合
        Set<Entry<Integer, String>> es = map.entrySet();
        //获取所有value的collection集合
        Collection<String> values = map.values();
        System.out.println(ks);
        System.out.println(es);
        System.out.println(values);
        int[] arr = {
    10,20,30,40,50};
        Stream<int[]> stream2 = Stream.of(arr);
    }
}

Stream的功能

Stream filter(Predicate p):

按照指定的条件对stream中数据进行过滤【满足保留】

Stream limit(int num):

只获取Stream中前num个元素

Stream skip(int num):

跳过前num个数据获取之后的数据

Stream map(Function f):

映射功能【把Stream中的数据映射为另一种数据】

Stream concat(Stream s1，Stream s2)：

这是一个静态方法
拼接两个stream流为一个stream流

toArray():

把stream流中的数据收集到数组中

collect(Collector c):

把stream流中的数据收集到指定的集合中
Collector ：参数的类型是一个接口获取可以通过工具类Collectors的方法获取
常用：
获取List集合：Collectors.toList()
获取Set集合： Collectors.toSet()

forEach(Consumer c):

用来使用stream流中的数据的

int count():

返回stream流中元素的个数

代码示例：

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamMethod {
    public static void main(String[] args) {
        String[] arr = {
    "菊花","露水","百合花","玫瑰红","牡丹","百合","玫瑰","牡丹绿"};
        Stream<String> stream2 = Stream.of(arr);
        // 过滤
        Stream<String> stream3 = stream2.filter((t)->{
    return t.length() == 2;});
        // 循环消费
        //stream3.forEach(System.out :: println);
        Stream<String> stream4 = stream3.limit(4);
        //stream4.forEach(System.out :: println);
        Stream<String> stream5 = stream4.skip(2);
        // stream5.forEach(System.out :: println);
        //Stream<char[]> stream6 = stream5.map((r)->{return r.toCharArray();});
        Stream<byte[]> stream6 = stream5.map((r)->{
    return r.getBytes();});
        stream6.forEach(System.out :: println);
        System.out.println("=================");
        Stream<String> of = Stream.of(arr);
        Stream<String> of2 = Stream.of(arr);
        Stream<String> concat = Stream.concat(of, of2);
        // concat.forEach(System.out :: println);
        // System.out.println(concat.count());// 16
        // 把Stream流变为数组
        // Object[] array = concat.toArray();
        // System.out.println(Arrays.toString(array));
        // 把Stream流变为集合
//        List<String> list = concat.collect(Collectors.toList());
//        System.out.println(list);
        Set<String> set = concat.collect(Collectors.toSet());
        System.out.println(set);
    }
}