Stream流详解

//将用户列表users转换为一个由Map组成的列表maps，其中每个Map包含两个键值对："text"和"value"。"text"键对应的值是用户的名字item.getName()，"value"键对应的值是用户的IDitem.getId()。利用StreamUtil类的listMap方法实现。 
	List<Map<String, ? extends Serializable>> maps = StreamUtil.listMap(users, item -> {
        return Map.of("text", item.getName(), "value", item.getId());
    });

Stream流的使用步骤

获取方式	方法名	说明
单列集合	default Stream stream()	Collection中的默认方法
双列集合	无 (先使用 keySet() entrySet() 转为单列集合)	无法直接使用stream流
数组	public staticStreamstream(T[]array)	Arrays工具类中的静态方法
一堆零散数据	public static Streamof(T…values)需要同种数据类型	Stream接口中的静态方法

单列集合获取Stream

System.out.println("单列集合*******************");
        //单列集合获取Stream流
        ArrayList<String> list=new ArrayList<>();
        //往list集合中添加数据

        Collections.addAll(list,"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o");
        //获取一条流水线 并把集合中的数据放到流水线上
        Stream<String> stream = list.stream();
        //使用终结方法打印流水线上的所有数据
        stream.forEach(s -> System.out.print(s+" "));

双列集合获取stream流

System.out.println("双列集合*******************");
        //双列集合 无法直接使用stream流
        //1.创建双列集合
        HashMap<String,Integer> hm=new HashMap<>();
        hm.put("a",1);
        hm.put("b",2);
        hm.put("c",3);
        hm.put("d",4);
        //3.获取stream流
        System.out.println("*****双列集合key");
        //s:表示流水线上的每一个数据
        hm.keySet().stream().forEach(System.out::println);//a b c d
        //第二种获取stream
        hm.entrySet().stream().forEach(System.out::println);//a=1 b=2 c=3  d=4

数组

Stream流的格式

Stream<T> filter(Predicate<? super T> predicate);
            -----> 参数：public interface Predicate<T>  (函数式接口)
                    ----> 抽象方法：boolean test(T t);
            -----> 参数：public interface Consumer<T>  (函数式接口)
                    ----> 抽象方法：boolean test(T t);

Stream流常用方法

**终结方法:**返回值类型不再是Stream接口本身类型的方法
**延迟方法:**返回值类型任然是Stream接口自身类型的方法,除了终结方法都是延迟方法

方法名称	方法作用	方法种类	是否支持链式调用
count	统计个数	终结方法	否
forEach	逐一处理	终结方法	否
filter	过滤	函数拼接	是
limit	取用前几个	函数拼接	是
skip	跳过前几个	函数拼接	是
map	映射	函数拼接	是
concat	组合	函数拼接	是

1. count: long count (); 统计流中的元素，返回long类型数据

List<String> list = new ArrayList<>();
        list.add("张老三");
        list.add("张小三");
        list.add("李四");
        list.add("赵五");
        list.add("张六");
        list.add("王八");
        long count = list.stream().count();
        System.out.println("集合中的元素个数是：" + count);
        输出结果：6

2. filter:

Stream<T> filter(Predicate<? super ?> predicate); 过滤出满足条件的元素

               参数Predicate：函数式接口，抽象方法：boolean test （T  t)

               Predicate接口：是一个判断接口

// 获取stream流
        Stream<String> stream = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
        // 需求：过滤出姓张的元素
        stream.filter((String name)->{
            return name.startsWith("张");
        }).forEach((String name)->{
            System.out.println("流中的元素" + name);
        });

3. forEach:

void forEach(Consumer<? super T> action)：逐一处理流中的元素
            参数 Consumer<? super T> action：函数式接口，只有一个抽象方法：void accept（T t)；
                   注意：
                       1.此方法并不保证元素的逐一消费动作在流中是有序进行的（元素可能丢失）
                       2.Consumer是一个消费接口（可以获取流中的元素进行遍历操作，输出出去），可以使用Lambda表达式

List<String> list = new ArrayList<>();
        list.add("张老三");
        list.add("张小三");
        list.add("李四");
        list.add("赵五");
        list.add("张六");
        list.add("王八");
 
        list.stream().forEach((String name)->{
            System.out.println(name);
        });
        list.stream().forEach(s->System.out::println);
        输出结果：
            张老三
            张小三
            李四
            赵五
            张六
            王八

4. limit:

Stream<T> limit(long maxSize);   取用前几个元素
	注意：
参数是一个long 类型，如果流的长度大于参数，则进行截取；否则不进行操作

// 获取流的长度
        Stream<String> stream1 = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
        // 需求：保留前三个元素
        stream1.limit(3).forEach((String name)->{
            System.out.println("流中的前三个元素是：" + name);
        });
        输出结果：
            流中的前三个元素是：张老三
            流中的前三个元素是：张小三
            流中的前三个元素是：李四

5. map:

<r> Stream <R> map(Function<? super T,? exception R> mapper;
                            参数Function<T,R>：函数式接口，抽象方法：R apply(T t);
                                Function<T,R>：其实就是一个类型转换接口（T和R的类型可以一致，也可以不一致）

// 获取Stream流
        Stream<String> stream1 = Stream.of("11","22","33","44","55");
        // 需求：把stream1流中的元素转换为int类型
        stream1.map((String s)->{
           return Integer.parseInt(s); // 将String类型的s进行转换为Integer类型的元素，并返回
        }).forEach((Integer i)->{
            System.out.println(i);  // 将转换后的int类型的元素逐一输出
        });
 
        输出结果：
            11
            22
            33
            44
            55

6.skip:

Stream<T> skip(long n);     跳过前几个元素
 注意：
    如果流的当前长度大于n，则跳过前n个，否则将会得到一个长度为0的空流

// 获取stream流
        Stream<String> stream = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
 
        stream.skip(3).forEach((String name)->{
            System.out.println(name);
        });
        输出结果：
            赵五
            刘六
            王七

7.concat:

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
            --> 合并两个流

Stream<String> stream1 = Stream.of("11","22","33","44","55");
        Stream<String> stream2 = Stream.of("张颜宇", "张三", "李四", "赵五", "刘六", "王七");
 
        // 需求：合并两个流
        Stream<String> stream = Stream.concat(stream1,stream2);
        stream.forEach((String name)->{
            System.out.print(name);
        });
 
        输出结果：
            1122334455张颜宇张三李四赵五刘六王七

收集Stream流

Stream流中提供了一个方法，可以把流中的数据收集到单例集合中

                <R, A> R collect(Collector<? super T, A, R> collector);     把流中的数据手机到单列集合中
                    返回值类型是R。R指定为什么类型，就是手机到什么类型的集合
                    参数Collector<? super T, A, R>中的R类型，决定把流中的元素收集到哪个集合中
                    参数Collector如何得到 ？，可以使用 java.util.stream.Collectors工具类中的静态方法：
                        - public static <T> Collector<T, ?, List<T>> toList()：转换为List集合
                        - public static <T> Collector<T, ?, Set<T>> toSet() ：转换为Set集合

List<String> list2 = new ArrayList<>();
        list2.add("张老三");
        list2.add("张小三");
        list2.add("李四");
        list2.add("赵五");
        list2.add("张六");
        list2.add("王八");
 
        // 需求：过滤出姓张的并且长度为3的元素
        Stream<String> stream = list2.stream().filter((String name) -> {
            return name.startsWith("张");
        }).filter((String name) -> {
            return name.length() == 3;
        });
 
        // stream 收集到单列集合中
        List<String> list = stream.collect(Collectors.toList());
        System.out.println(list);
 
        // stream 收集到单列集合中
        Set<String> set = stream.collect(Collectors.toSet());
        System.out.println(set);

创建不可变集合 List.of() Set.of() Map.of() //java9以上版本

**意义:**不想让别人修改集合中的内容(只能查询)
创建list 中的不可变集合

List<String> list = List.of("张三", "李四");//不可添加删除修改
        list.get(0);
        //List 迭代器遍历
        Iterator<String> itList = list.iterator();
        while (itList.hasNext()) {
            String s = itList.next();
            System.out.println(s);
        }
        //Set 当我们要获取一个不可变的Set集合时,里面的参数一定要保证唯一性
        Set<String> set = Set.of("张三", "李四");//不可添加删除修改
        Iterator<String> itSet = set.iterator();
        while (itSet.hasNext()) {
            String s = itSet.next();
            System.out.println(s);
        }
        //Map 键不能重复 Map里面的of方法,参数有上限,最多只能传递20个参数(10个键值对)
        Map<String, String> map = Map.of("张三", "南京", "李四", "北京");
        Set<Map.Entry<String, String>> entries = map.entrySet();//获取所有键值对对象
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }

        //1.创建一个普通的Map集合
        //添加11条数据
        HashMap<String, String> hm = new HashMap<>();
        hm.put("001", "张三");
        hm.put("002", "李四");
        hm.put("003", "王五");
        hm.put("004", "赵六");
        hm.put("005", "田七");
        for (int i = 6; i < 11; i++) {
            hm.put("00" + i, String.valueOf(i));
        }
        //2.获取一个不可变集合
        //获取所有的键值对对象
        Set<Map.Entry<String, String>> entries1 = hm.entrySet();
        //把entries变成数组  toArray方法在底层会比较集合的长度跟数组的长度 如果集合长度>数组长度  
		//它会根据实际数据个数 重新创建数组
        Map.Entry[] arr = entries1.toArray(new Map.Entry[0]);//带形参的toArray方法
        //不可变的map集合
        Map map0 = Map.ofEntries(arr);
        //简写
        Map<Object, Object> map1 = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));//9版本
        Map<String, String> map2 = Map.copyOf(hm);//10版本
        for (Map.Entry<Object, Object> entry : map1.entrySet()) {
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }

Stream流处理

ArrayList<String> list1 = new ArrayList<>();
        list1.add("张三");
        list1.add("李四");
        list1.add("王五");
        list1.add("赵六");
        list1.add("张二六");
        //1.把所有以"张"开头的元素存储到新集合中
        Object[] list2 = list1.stream().filter(name -> name.startsWith("张")).toArray();
        for (Object s : list2) {
            System.out.println(s);
        }
        System.out.println("********************");
        //2.把"张"开头的,长度为3的元素存储到新集合中
        list1.stream().filter(name -> name.startsWith("张")).
                filter(name -> name.length() == 3).forEach(System.out::println);