Stream流

Stream流

1. 理解Steam流

类似于我们生活中的流水线，将数据以流的方式进行过滤处理

2. Stream对象的获取方式

2.1 Collection下的集合获取流的方式，使用集合对象调用stream()

2.2 Map中获取流对象的方式，不能直接获取

1. Map获取流对象，不能直接获取，要先变成单列集合

   第一步：获取键的流对象

   keySet().stream()

2. 第二步：获取值的流对象

   values().stream()

3. 第三步：获取键值对的流对象

   entrySet().stream()

2.3 数组获取流对象的方式

1. 通过Stream中of方法获取流对象

2. Stream.of(数组)

public class Demo01 {
    public static void main(String[] args) {
        //单列集合获取流对象
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        //直接使用集合对象名称，调用stream方法
        Stream<Integer> stream = list.stream();//返回值就是一个流对象

        //Map获取流对象，不能直接获取，要先变成单列集合
        HashMap<String,String> h = new HashMap<>();
        //获取键的流对象
        Stream<String> stream1 = h.keySet().stream();
        //获取值的流对象
        Stream<String> stream2 = h.values().stream();
        //获取键值对的流对象
        Stream<Map.Entry<String, String>> stream3 = h.entrySet().stream();

        //数组获取流对象
        int[] arr = {1,2,3};
        Stream<int[]> arr1 = Stream.of(arr);

    }
}

3. Stream的常用方法

3.1 分类：

1. 终结方法：调用之后的返回值就不再是Stream类型了，相当于Stream终结了，就不能再调用流中的方法了
2. 非终结方法：调用完成之后返回值还是Stream类型，可以继续调用Stream中的方法对流进行处理

3.2 方法介绍：

非终结方法：

1. filter(Predicate<? super T> p):

根据断言型接口描述的判断条件，对流中的数据进行过滤，保留判断为true的元素

2. limit(long size):

根据参数描述的个数，对流中的元素进行截取，截取前size个元素

3. skip(long size):

根据参数描述的个数，跳过前size个元素，截取剩余的元素

4. map(Function<? super T,R> fun):

将流中的所有的T类型的数据，都根据fun这个函数式接口转换成R类型的参数

终结方法：

1. forEach(Consumer<? super T> con):

将流中的数据，使用con描述的方式进行处理

long count() 获取流中元素的个数

2. Stream静态方法

concat() 拼接流对象

public class Demo02 {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("金童");
        names.add("雨婷婷");
        names.add("金沛沛");
        names.add("娄肖龙龙");
        names.add("晨翔翔翔");
        names.add("童童");
        Stream<String> s = names.stream();
        Stream<String> limit = s.limit(3);
        //拼接流对象
        Stream<String> skip = names.stream().skip(5);
        //返回拼接后的流对象
        Stream<String> concat = Stream.concat(limit, skip);
        concat.forEach(System.out::println);

    }

    private static void test5(Stream<String> s) {
        //map放函数型函数式接口
        //想要将流中所有字符串处理，返回每个名字的字符个数
        s.map(x->x.length()).forEach(System.out::println);
    }

    private static void test4(Stream<String> s) {
        //limit截取流中的前多少个元素
        //判断其中以童结尾的姓名
//        s.limit(4).filter(x->x.endsWith("童")).forEach(System.out::println);

        //skip 跳过流中前多少个元素，截取剩余部分
        s.skip(4).filter(x->x.endsWith("童")).forEach(System.out::println);
    }

    private static void test3(Stream<String> s) {
        //非终结方法 filter 断言型函数式接口，保留判断为true 的元素
        //使用断言型函数式接口元素长度大于3的元素，大于3保留
//        s.filter(x->x.length()>3).forEach(System.out::println);
        //判断小于等于3而且名字以童结尾的
        s.filter(x->x.length()<=3).filter(x->x.endsWith("童")).forEach(System.out::println);
    }

    private static void test2(Stream<String> s) {
        //终结方法 forEach  调用了终结方法之后，就不能再使用这个流对象了
        //如果想要使用，可以获取新的流对象
//        stream has already been operated upon or closed 对象已经被操作过了或者关闭了
        Consumer<String> c = (x) -> System.out.println(x);
        s.forEach(c);
//        s.forEach(c);
    }

    private static void test(ArrayList<String> names) {
        Stream<String> stream = names.stream();
        //终结方法，获取流中的元素的个数
        //终结方法调用之后，该流对象就不能再使用了
        long count = stream.count();
        System.out.println(count);
    }
}