Stream流的学习使用

Stream流便于操作数据，首先想象将数据放在流水线上，使用中间方法处理数据，再使用终结方法处理，注意使用完终结方法后便无法再进行操作。

 单列集合可以获取流后直接操作数据，但是双列集合不可以，必须变成单列集合才可以进行操作。

public class Demo2 {
    public static void main(String[] args) {
        //双列集合的Stream流使用方法
        HashMap<String, Integer> hm = new HashMap<>();
        hm.put("a",1);
        hm.put("b",2);
        hm.put("c",3);
        hm.put("d",4);
        //变为单列集合使用
        //第一种，存储键
        hm.keySet().stream().forEach(k -> System.out.println(k));
        System.out.println("---------------");
        //第二种，存储键值对
        hm.entrySet().stream().forEach(kv -> System.out.println(kv));
    }
}

运行结果 

          a
          b
          c
          d
        ---------------
        a=1
        b=2
        c=3
        d=4

数组流操作

public class Demo3 {
    public static void main(String[] args) {
        //创建一个引用数据类型的数组和一个基本类型数组
        String[] arr1 = {"a","b","c","d"};
        int[] arr2 = {1,2,3,4,5,6};
        //使用stream流
        Arrays.stream(arr1).forEach(s -> System.out.println(s));

        Arrays.stream(arr2).forEach(s -> System.out.println(s));
        //小细节
        //of方法的形参是一个可变参数，可以传输零散数据，也可以传送数组
        //数组在使用stream的静态方法of时只能使用引用数据类型，不然其会将整个数组视为一个元素，添加入stream中。
        Stream.of(arr1).forEach(s -> System.out.println(s));
        Stream.of(arr2).forEach(s -> System.out.println(s));//打印结果是一个地址值[I@448139f0
    }

 零散数据

public class Demo4 {
    public static void main(String[] args) {
        //零散数据
        Stream.of(1,2,3,4,5,6).forEach(s -> System.out.println(s));

        Stream.of("a","b","c").forEach(s -> System.out.println(s));
    }
}

中间方法有filter过滤，limit只获取指定数字的数据，skip跳过指定数字的数据，distinct去重，但是依赖hashcode和equals方法（当底层方法的不满足需求时需要重写），concat合并两个流，map转换流中的数据类型。

 过滤

public class 流 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        //利用方法批量添加数据
        Collections.addAll(list,"李二三","李四","王五","李六","李七八","李九十");
        System.out.println(list);
        System.out.println("------------");
        //Stream流过滤数据 lambda表达式版
        list.stream().filter(name -> name.startsWith("李")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));
        System.out.println("------------");
        Stream流过滤数据 未简化版
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String name) {
                return name.startsWith("李");
            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(String name) {
                return name.length() == 3;
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String name) {
                System.out.println(name);
            }
        });
    }
}

 转换数据类型

public class Demo5 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        //批量添加
        Collections.addAll(list,"11c-22","hpy-26","lzh-30","syz-40");
        //修改数据类型
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                //据我的理解应该是每次切割完，人名放0索引，数字放1索引。
                String[] arr = s.split("-");
                String ageS = arr[1];
                int age = Integer.parseInt(ageS);
                return age;
            }
        }).forEach(s -> System.out.println(s));
        //lambda表达式
        list.stream()
                .map(s -> Integer.parseInt(s.split("-")[1]))
                .forEach(s -> System.out.println(s));
    }
}

终结方法有foreach遍历，count统计，toArray收集流中的数据，放到数组中，collect收集流中的数据，放到集合中。

 

括弧这个是黑马java课上阿伟老师写的注释，我觉很有用，强烈建议听一听，百万级ppt

collect方法 

public class Demo6 {
    public static void main(String[] args) {
        //收集流中的数据放到集合中 collect方法
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        //批量添加
        Collections.addAll(list,"11c-22-男","hpy-26-男","lzh-30-女","syz-40-男");

        //
        //放入list集合中
        List<String> newList1 = list.stream().filter(s -> "男".equals(s.split("-")[2])).collect(Collectors.toList());
        System.out.println(newList1);
        //放入set集合中
        //set集合有去重的作用，而list没有
        Set<String> newList2 = list.stream().filter(s -> "男".equals(s.split("-")[2])).collect(Collectors.toSet());
        System.out.println(newList2);

        //放入双列集合map中
        //tomap方法参数1键的生成规则，参数2值的生成规则。
        //泛型第一个参数时流中的数据类型，对应apply方法的形参，第二个是键的类型对应返回值的类型
        //apply方法方法体是生成键的代码，返回值 已经生成的键
        Map<String, Integer> newMap = list.stream().filter(s -> "男".equals(s.split("-")[2]))
                .collect(Collectors.toMap(new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        return s.split("-")[0];
                    }
                }, new Function<String, Integer>() {//相同的第一个参数对应形参参数类型，第二个参数Integer对应返回值参数Integer。
                    @Override                       //这里的apply方法方法体是生成值的代码，返回值 已经生成的值
                    public Integer apply(String s) {
                        return Integer.parseInt(s.split("-")[1]);
                    }
                }));
        //这里报了一个错误，因为键重复了，所以我把上面重复的删除了
        System.out.println(newMap);
        //简化版
        Map<String, Integer> newMap2 = list.stream()
                .filter(s -> "男".equals(s.split("-")[2]))
                .collect(Collectors.toMap(s -> s.split("-")[0]
                        , s -> Integer.parseInt(s.split("-")[1])));
        System.out.println("简化版" + newMap2);
    }
}