Stream流的使用

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

package Day0308;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
/**
 * @author CF
 * @version 1.0
 * @date 2023/2/8 14:23
 */
public class Test01 {
    /*
        Stream流中三类方法之一 :  获取方法
        1 单列集合
           可以使用Collection接口中的默认方法stream()生成流
           default Stream<E> stream()
        2 双列集合
            双列集合不能直接获取 , 需要间接的生成流
            可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流
        3 数组
           Arrays中的静态方法stream生成流
     */
    public static void main(String[] args) {
        // 单列集合的获取
        method1();
        // 双列集合的获取
        method2();
        // 数组获取
        method3();
    }
    private static void method1() {
        int[] arr = {1, 2, 3, 4, 5, 6};
        Arrays.stream(arr).forEach(s -> System.out.println(s));
    }
    private static void method2() {
        HashMap<String, String> hm = new HashMap<>();
        hm.put("001", "曹植");
        hm.put("002", "曹丕");
        hm.put("003", "曹熊");
        hm.put("004", "曹冲");
        hm.put("005", "曹昂");
        // 获取map集合的健集合 , 在进行输出打印
        hm.keySet().stream().forEach(s -> System.out.println(s));
        // 获取map集合的entry对象 , 在输出打印
        hm.entrySet().stream().forEach(s -> System.out.println(s));
    }

    private static void method3() {
        // 可以使用Collection接口中的默认方法stream()生成流
        ArrayList<String> list = new ArrayList<>();
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("马尔扎哈");
        list.add("欧阳娜娜");
        list.stream().forEach(s -> System.out.println(s));
    }
}

*****二:中间方法

• 流水线上的操作。

• 一次操作完毕之后，还可以继续进行其他操作*****

  /*
  Stream流中三类方法之一 : 中间方法
  1 Stream filter(Predicate predicate)：用于对流中的数据进行过滤
  Predicate接口中的方法 : boolean test(T t)：对给定的参数进行判断，返回一个布尔值
  2 Stream limit(long maxSize)：截取指定参数个数的数据
  3 Stream skip(long n)：跳过指定参数个数的数据
  4 static Stream concat(Stream a, Stream b)：合并a和b两个流为一个流
  5 Stream distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
  6 Stream sorted () : 将流中元素按照自然排序的规则排序
  7 Stream sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序
  */

package Day0308;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Predicate;
import java.util.stream.Stream;
/**
 * @author CF
 * @version 1.0
 * @date 2023/2/8 14:32
 */
public class Test02 {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            list.add("张无忌");
            list.add("张翠山");
            list.add("张三丰");
            list.add("谢广坤");
            list.add("赵四");
            list.add("刘能");
            list.add("小沈阳");
            list.add("张良");
            list.add("张良");
            list.add("张良");
            list.add("张良");

            // Stream<T> limit(long maxSize)：截取指定参数个数的数据
            // list.stream().limit(3).forEach(s -> System.out.println(s));

            // Stream<T> skip(long n)：跳过指定参数个数的数据
            // list.stream().skip(3).forEach(s-> System.out.println(s));

            // Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
            // list.stream().distinct().forEach(s->{System.out.println(s);});

        }

        // // Stream<T> sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序
        private static void method3(ArrayList<String> list) {
            list.stream().sorted(new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return o1.length() - o2.length();
                }
            }).forEach(s->{
                System.out.println(s);
            });
        }

        // Stream<T> sorted () : 将流中元素按照自然排序的规则排序
        private static void method3() {
            ArrayList<Integer> list2 = new ArrayList<>();
            list2.add(3);
            list2.add(1);
            list2.add(2);
            list2.stream().sorted().forEach(s->{
                System.out.println(s);
            });
        }

        // // static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
        private static void method2(ArrayList<String> list) {
            ArrayList<String> list2 = new ArrayList<>();
            list2.add("迪丽热巴");
            list2.add("古力娜扎");
            list2.add("欧阳娜娜");
            list2.add("马尔扎哈");

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

        // Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
        private static void method1(ArrayList<String> list) {
            // filter方法会获取流中的每一个数据
            // 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));

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

三 : 终结方法

package Day0308;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Predicate;
import java.util.stream.Stream;
/**
 * @author CF
 * @version 1.0
 * @date 2023/2/8 14:32
 */
public class Test03 {

/*
    Stream流中三类方法之一 :  终结方法
    1 void forEach(Consumer action)：对此流的每个元素执行操作
        Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作
    2 long count()：返回此流中的元素数

 */
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("张翠山");
        list.add("张三丰");
        list.add("谢广坤");

        // long count()：返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
    }
    // void forEach(Consumer action)：对此流的每个元素执行操作
    private static void method1(ArrayList<String> list) {
        // 把list集合中的元素放在stream流中
        // forEach方法会循环遍历流中的数据
        // 并循环调用accept方法 , 把数据传给s
        // 所以s就代表的是流中的每一个数据
        // 我们只要在accept方法中对数据做业务逻辑处理即可
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        System.out.println("=====================");

        list.stream().forEach( (String s) -> {
            System.out.println(s);
        });

        System.out.println("=====================");

        list.stream().forEach(  s -> { System.out.println(s); });
    }

}

Stream流中的收集方法

import java.util.ArrayList;

/*
    Stream流的收集操作 : 第一部分

    需求：过滤元素并遍历集合
        定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
        将集合中的奇数删除，只保留偶数。
        遍历集合得到2，4，6，8，10

    结论：在Stream流中无法直接修改集合,数组等数据源中的数据。
 */
public class StreamDemo5 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }

        list.stream().filter(num -> num % 2 == 0).forEach(num -> System.out.println(num));

        System.out.println("=============");

        // 结论：在Stream流中无法直接修改集合,数组中的数据。
        System.out.println(list);
    }
}

结论：在Stream流中无法直接修改集合,数组中的数据

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/*

    Stream流的收集操作 : 第二部分

    使用Stream流的方式操作完毕之后，我想把流中的数据起来，该怎么办呢？

    Stream流的收集方法
    R collect(Collector collector) : 此方法只负责收集流中的数据 , 创建集合添加数据动作需要依赖于参数

    工具类Collectors提供了具体的收集方式
    public static <T> Collector toList()：把元素收集到List集合中
    public static <T> Collector toSet()：把元素收集到Set集合中
    public static  Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中


    需求 :
        定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
        将集合中的奇数删除，只保留偶数。
        遍历集合得到2，4，6，8，10
 */
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        list.add(10);
        list.add(10);
        list.add(10);
        list.add(10);
        list.add(10);

        // collect只负责收集流中的数据
        // Collectors.toList()会负责在底层创建list集合 ,并把数据添加到集合中 , 返回集合对象
        List<Integer> list2 = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toList());
        System.out.println(list2);

        Set<Integer> set = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toSet());
        System.out.println(set);

    }
}

import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;

/*
    Stream流的收集操作 : 第三部分

    1 创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
        "zhangsan,23"
        "lisi,24"
        "wangwu,25"
    2 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值

    收集方法 :
    public static  Collector toMap(Function keyMapper  ,   Function valueMapper)：把元素收集到Map集合中
 */
public class StreamDemo7 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("lisi,24");
        list.add("wangwu,25");

        // collect 只负责收集数据
        // Collectors.toMap负责在底层创建集合对象 , 添加元素
        // toMap方法中的s就是代表的是集合中的每一个元素
        // 第一个参数 : 如何获取map集合中的键
        // 第二个参数 : 如何获取map集合中的值
        Map<String, String> map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) > 23).collect(
                Collectors.toMap(
                        (String s) -> {
                            return s.split(",")[0];
                        }
                        ,
                        (String s) -> {
                            return s.split(",")[1];
                        }
                )
        );
        System.out.println(map);
    }
}