Stream流

生成流

通过数据源（集合，数组等）生成流

list.stream（）

中间操作

一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤、映射，返回一个新的流，交给下一个操作使用

例如：filter（）；

终结操作

一个流只能有一个终结操作，当这个操作执行完毕后，流就被用光了，所以，这必定是流最后一个操作。

例如：forEach（）；

//使用stream流，输出list中以w开头的且长度大于3的字符串
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("wang");
        arrayList.add("wag");
        arrayList.add("li");
        arrayList.add("zha");
        arrayList.stream().filter(x -> x.startsWith("w")).filter(x->x.length()>3).forEach(System.out::println);
    }
Stream流的生成方式

Stream流的常见生成方式

1Collection体系的集合可以使用默认方法stream（）生成流

{
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();
    }

2Map体系的集合间接的生成流

{
        Map<String,Integer> map = new HashMap<>();
        //得到键的stream流
        Stream<String> stream = map.keySet().stream();
        //得到值的stream流
        Stream<Integer> stream1 = map.values().stream();
        //得到map对象的stream流
        Stream<Map.Entry<String, Integer>> stream2 = map.entrySet().stream();
    }

3数组可以通过Stream接口的静态方法of（T…values）生成流

{
        int[] a = {1,2,4,5,6,7,5};
        Stream<int[]> a1 = Stream.of(a);
    }
Stream流的常见中间操作方法

1Stream filter(Predicate predicate):用于对流中的数据进行过滤

Predicate 接口中的方法 boolean test(T t):对给定的参数进行判断，返回一个boolean值

//使用filter方法过滤元素
{
        List<String> arr = new ArrayList<>();
        arr.add("wang");
        arr.add("wag");
        arr.add("ng");
        arr.add("g");
        arr.stream().filter(x->x.startsWith("w")).forEach(System.out::println);
    }

2Stream limit(long maxsize) :返回此流中元素组成的流，截取指定参数个数的数据

3Stream skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流

4static Stream concat(Stream a,Stream b):合并a，b两个流为一个流

5Stream distinct():返回由该流的不同元素（根据Object.equals(object)）组成的流

6Stream sorted():返回由此流的元素组成的流，根据自然顺序排序

7Stream sorted(Comparator comparator) :返回由该流的元素组成的流，根据提供的Comparator进行排序

8 Stream map(Function mapper) :返回由给定函数应用于此流的元素的结果组成的流

Function 接口中的方法 R apply（T t）

{
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("10");
        arrayList.add("20");
        arrayList.add("33");
        arrayList.add("45");
        arrayList.add("56");
        arrayList.stream().map(Integer::parseInt).forEach(System.out::println);
    }

9IntStream mapToInt(ToIntFunction mapper):返回一个Inputstream其中包含将给定函数应用于此流的元素的结果

intStream：表示原始的int流

ToIntFunction接口中的方法 int applyAsint（T value）

{
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("10");
        arrayList.add("20");
        arrayList.add("33");
        arrayList.add("45");
        arrayList.add("56");
        //mapToInt 返回IntStream流对象 该对象的sum（）方法可返回流中元素的和
        int sum = arrayList.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
    }
Stream流中常见的终结操作的方法

void forEach（Consumer action）:对此流的每个元素执行操作

Consumer接口中的方法 void accept（T t）对给定的参数执行此操作

long count（）：返回此流中的元素数

Stream流的收集操作

对数据使用Stream流的方式操作完毕后，我想把流中的数据放入到集合中，该怎么办呢？

Stream流的收集方法

R collect（Collector collector）

但是这个收集方法的参数是一个Collector接口

工具类Collectors提供了具体的收集方式

public static Collector toList():把元素收集到List集合中

{
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("10");
        arrayList.add("20");
        arrayList.add("33");
        arrayList.add("45");
        arrayList.add("56");
        Stream<String> stream = arrayList.stream();
        List<String> a = stream.collect(Collectors.toList());
        for (String s : a) {
            System.out.println(s);
        }
    }

public static Collector toSet():把元素收集到Set集合中

public static Collector toMap(FUnction keyMapper,Function valueMapper) :把元素收集到Map集合中

{
        String[] s= {"wang,16","li,15","zahng,12","jing,8","ma,7"};
        Stream<String> stream = Stream.of(s).filter(x -> Integer.parseInt(x.split(",")[1]) > 10);
        Map<String, Integer> collect = stream.collect(Collectors.toMap(m -> m.split(",")[0], n -> Integer.parseInt(n.split(",")[1])));
        System.out.println(collect);
    }