Stream流

ArrayList arrayList = new ArrayList<>(List.of(“张三丰”, “张三”, “李四”, “王二麻”));
ArrayList arrayList1 = new ArrayList<>();
for (String s : arrayList) {
if(s.startsWith(“张”)){
arrayList1.add(s);
}
}
System.out.println(arrayList1);
ArrayList arrayList2 = new ArrayList<>();
for (String s : arrayList1) {
if(s.length()==3){
arrayList2.add(s);
}
}
System.out.println(arrayList2);

//上面等价于下面
arrayList.stream().filter(s->s.startsWith(“张”)).filter(s->s.length()==3).forEach(s-> System.out.println(s));

    //Stream流的三类方法：

    //1、获取Stream流：创建一条流水线，并把数据放到流水线上准备进行操作

    //1)单列集合：可以使用Collection 接口中的默认方法stream（）生成流
    ArrayList<String> arrylist = new ArrayList<>(List.of("A","B","C"));
    Stream<String> stream = arrylist.stream();
    stream.forEach(s -> System.out.println(s));

    //2）双列集合：间接生成流，先通过keySet或者entrySet获取一个Set集合，再获取stream流
    HashMap<String, Integer> stringIntegerHashMap = new HashMap<>(Map.of("zhangsan",23,"lisi",24,"wangwu",25));
    Set<String> keyset = stringIntegerHashMap.keySet();
    Stream<String> stream1 = keyset.stream();
    stream1.forEach(s -> System.out.println(s));
    //等价于keyset.stream().forEach(s -> System.out.println(s));

    Set<Map.Entry<String, Integer>> entries = stringIntegerHashMap.entrySet();
    entries.stream().forEach(s-> System.out.println(s));

    //3)数组:Arrays中的静态方法stream生成流
    int[] arr = {1,2,3,4,5};
    Arrays.stream(arr).forEach(s-> System.out.println(s));
    
    //4）同种数据类型的多个数据（单独存在，不放入数组集合）：Stream.of(可变参数)生成流
    Stream.of(1,2,3,4).forEach(s-> System.out.println(s));

//2、中间方法：流水线上的操作，可以多次操作

    ArrayList<String> list = new ArrayList<String>(List.of("王二麻子", "苦茶子", "苦茶子", "慧慧子", "奥特曼", "李春花"));

    //1)filter
    //1>filter里面写匿名内部类
    //filter方法获取流中的每一个数据，而test方法中的s就依次表示流中每一个数据
    //如果判断为true，当前数据则留下，判断为false则不要
    list.stream().filter(new Predicate<String>() {
        @Override
        public boolean test(String s) {
            boolean result = s.startsWith("慧");
            return result;
        }
    }).forEach(s -> System.out.println(s));
    System.out.println("============================");
    //2>因为Predicate接口中只有一个抽象方法test，所以filter里面写lambda表达式
    list.stream().filter(s -> s.startsWith("慧")).forEach(s -> System.out.println(s));
    System.out.println("============================");

    //2)limit:截取指定参数个数的数据
    list.stream().limit(4).forEach(s -> System.out.println(s));
    System.out.println("============================");

    //3)skip:跳过指定参数个数的数据
    list.stream().skip(3).forEach(s -> System.out.println(s));
    System.out.println("============================");

    //4)Stream.concat(Stream a,Stream b):合并a和b两个流,看结果似乎自动去重
    ArrayList<String> list1 = new ArrayList<>(List.of("李四", "王五"));
    Stream<String> s1 = list.stream();
    Stream<String> s2 = list1.stream();
    Stream<String> concatStream = Stream.concat(s1, s2);
    concatStream.forEach(s -> System.out.println(s));
    //等价于Stream.concat(list.stream(), list1.stream()).forEach(s -> System.out.println(s));
    System.out.println("===========================");
    //5)distinct：去除重复元素，以来hashCode和equals方法
    list.stream().distinct().forEach(s -> System.out.println(s));
    System.out.println("===========================");

    //3、终结方法：一个Stream流只能有一个终结方法，是流水线上的最后一个操作

    //1)forEach(Consumer action):对流的每个元素操作
    //1>匿名内部类方式
    //Consumer接口的方法accept：对给定的参数执行操作
    //在forEach方法底层，会循环获取流中每一个数据，并调用accept方法，把每一个数据传给accept，s就代表每一个数据，在accept里写处理代码即可
    list.stream().forEach(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });
    System.out.println("==========================");
    //lambda表达式方式
    list.stream().forEach(s -> System.out.println(s));
    System.out.println("==========================");

    //2)count():返回流中的元素个数
    long count = list.stream().count();
    System.out.println(count);
    System.out.println("==========================");

    //注意：Stream上对数据的操作仅限于在流上，对于集合或数组里面的数据并不影响，无法改变，要想把操作的数据保存，那么就要用到收集方法
    //3)collect()方法
    //collect只负责收集数据，但不负责创建容器，也不负责把数据添加到容器中
    //创建容器并添加数据：Collectors.toList()或者Collectors.toSet()或Collectors.toMap()
    List<String> tolist = list.stream().filter(s -> s.startsWith("苦")).collect(Collectors.toList());
    System.out.println(tolist);
    Set<String> tolist1 = list.stream().filter(s -> s.startsWith("苦")).collect(Collectors.toSet());
    System.out.println(tolist1);
    System.out.println("==========================");

    ArrayList<String> list2 = new ArrayList<String>(List.of("zhangsan,23", "lisi,24", "wangwu,25"));

    Map<String, Integer> map = list2.stream().filter(s -> {
        String[] split = s.split(",");
        int age = Integer.parseInt(split[1]);
        return age >= 24;
    }).collect(Collectors.toMap(
            s -> {
                return s.split(",")[0];
            }
            ,
            s -> {
                return Integer.parseInt(s.split(",")[1]);
            }

    ));
    System.out.println(map);