Stream流

流：就像流水线一样

先得到一条Stream流，并把数据放上去

利用Api进行各种操作

分为中间方法和终结方法

单列集合

        //1.单列集合获取Stream流
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "a", "b", "v");

        //获取到一条流水线，并把集合中的数据放到流水线上
/*        Stream<String> stream1 = list.stream();
        //使用终结方法打印所有数据
*//*        stream1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*//*
         */
        list.stream().forEach(s -> System.out.println(s));
        

双列集合

//双列集合，不能直接使用stream

//1.创建双列集合
HashMap<String, Integer> hm = new HashMap<>();
hm.put("a", 1);
hm.put("b", 2);
hm.put("c", 3);
hm.put("d", 4);
hm.put("e", 5);

//2.第一zhong获取stream
hm.keySet().stream().forEach(s -> System.out.println(s));

//3.第二种获取
hm.entrySet().stream().forEach(s -> System.out.println(s));

数组

//数组
//1.创建数组
int[] arr = {1, 2, 3, 4, 5};

//2.获取stream流
Arrays.stream(arr).forEach(s -> System.out.println(s));

零散数据

//一堆零三数据

Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));

中间方法

中间方法，返回新的stream流，原来的stream只能使用一次，建议使用链式编程

修改stream流中的数据，不会影响本身的

过滤

ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"aaa,","aaaa","bbb","aab");

//filter过滤
list.stream().filter(new Predicate<String>() {
    @Override
    public boolean test(String s) {
        //如果返回值为true,留下
        s.startsWith("a");
        return s.startsWith("a");
    }
}).forEach(s-> System.out.println(s));

//链式编程

list.stream().filter(s->s.startsWith("张")).forEach(s-> System.out.println(s ));

获取，跳过

/*
 * limit 获取前几个元素
 * skip  跳过前几个元素
 *
 * */

list.stream().limit(3)
        .forEach(s -> System.out.println(s));

list.stream().skip(4)
        .forEach(s -> System.out.println(s));

去重 合并

/*
 *
 * distinct  元素去重，依赖于哈市Code和equals方法
 *
 * concat       合并a，b为一个流
 *

 * */

ArrayList<String> list1=new ArrayList<>();
Collections.addAll(list1,"aaaa","ab","aaaaaa","bbbbbb","ccccccccc","abccc","aaaa","ab");

ArrayList<String> list2=new ArrayList<>();
Collections.addAll(list2,"bbbb","cccc");

list1.stream().distinct().forEach(s-> System.out.println(s));

Stream.concat(list1.stream(),list2.stream()).forEach(s-> System.out.println(s));

类型转换

/*
 * map   转换流中的数据类型
 * */

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "lbx-18", "zjy-18");

//只获取里面的年龄并打印
//String->int

//方法内部的s表示流里的每一个数据
//return 表示转换以后的数据

list.stream().map(new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        String[] split = s.split("-");
        return Integer.parseInt(split[1]);
    }
}).forEach(s-> System.out.println(s));
System.out.println("=======================");
list.stream().map(s->Integer.parseInt(s.split("-")[1])).forEach(s-> System.out.println(s));

终结方法

遍历

/*
 * 泛型：流中数据的类型
 * 形参s 以此表示流的每一个数据
 *
 *
 * */
list1.stream().forEach(new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
});


list1.stream().forEach(s -> System.out.println(s));

统计

//统计
long count = list1.stream().count();
System.out.println(count);

收集

收集到数组

        /*
        * 泛型：是一个具体类型的数组
        * apply中的形参：流中数据的个数，要跟数组的长度保持一致
        * 返回值：具体类型的数组
        * */

        //toArray方法的参数的作用：创建一个指定类型的数组
        //底层：会依次得到流李的每一个元素，并把数据存到数组当中
        //toArray方法的返回值：是一个装着流里面所有数据的数组
/*        String[] arr= list1.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(Arrays.toString(arr));*/

        String[] arr2 = list1.stream().toArray(value -> new String[value]);
        System.out.println(Arrays.toString(arr2));
    }

收集到集合

//收集到map
//收集所有男性
//确认键为姓名，值为年龄

Map<String, Integer> newMap = list.stream()
        .filter(s -> "男".equals(s.split("-")[1]))
        /*
         * toMap:两个参数
         * 参数1:键的生成规则
         * 参数2：值的生成规则
         * 参数一：
         *       Function泛型一：表示流中每一个数据的类型
         *               泛型二：表示Map集合中键的数据类型
         *       方法apply形参：表示流李每一个数据
         *               方法体：生成键的代码
         *
         *
         * 参数二：
         *      Function泛型一：表示流中每一个数据的类型
         *               泛型二：表示Map集合中值的数据类型
         *                   方法apply形参：生成值的代码
         *               方法体：已经生成的值
         *
         * 注意点：键不能重复！！
         * */
        .collect(Collectors.toMap(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.split("-")[0];
            }
        }, new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s.split("-")[2]);
            }
        }));
System.out.println(newMap);

Map<String, Integer> Map = list.stream()
        .filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toMap(
                s -> s.split("-")[0],
                s -> Integer.parseInt(s.split("-")[2])
        ));
System.out.println(Map);