Stream流简单介绍(努力还需要理由的话就是笑话了)

最新推荐文章于 2022-08-25 15:03:46 发布

阿星在努力

最新推荐文章于 2022-08-25 15:03:46 发布

阅读量370

点赞数 5

文章标签： java-ee

本文链接：https://blog.csdn.net/weixin_50991263/article/details/123700795

版权

本文详细介绍了Java Stream流的使用，包括如何创建流、遍历集合、过滤操作、限制与跳过操作、合并流、去重以及收集操作。通过实例代码展示了如何利用Stream流处理数据，如筛选以特定字符开头的字符串、获取指定长度的元素，以及将数据收集到不同的集合中。此外，还讲解了Stream流的终结方法，如forEach和count，以及如何将数据收集到Map中。

摘要由CSDN通过智能技术生成

Stream流
   体验Stream流
   需求：按照要求创建完成集合得创建和遍历，一个集合存储多个字符串，把集合张开头得字符串存储到另一个长度为3得集合遍历集合

public class test {
            public static void main(String[] args) {
                ArrayList<String>  list=new ArrayList<>();
                list.add("张三丰");
                list.add("张四疯");
                list.add("张五");
                list.add("赵六");
                list.add("王七");
                //遍历list集合把以张开头得元素添加到list2种
                ArrayList<String> list2=new ArrayList<>();
                for (String s : list) {
                    if (s.startsWith("张")){
                        list2.add(s);
                    }
                }
                //遍历list3  把长度为3得字符串添加到list3种
                ArrayList<String>  list3=new ArrayList<>();
                for (String s : list2) {
                    if (s.length()==3){
                        list3.add(s);
                    }
                }
                for (String s : list3) {
                    System.out.println(s);
                }
        
                //Stream 流
                list.stream().filter(s->s.startsWith("张")).
                        filter(s->s.length()==3).
                        forEach(s-> System.out.println(s));
            }
        }

       Stream得获取方法
       单列集合
               可以使用Collection接口得默认方法Stream()生成流
               default Stream<E> stream()
               集合对象.stream();
       双列集合
               间接得生成流
               可以先通过keySet或者entrySet获取一个Set集合，再获取Stream
               不能直接获取，需要间接获取
               集合对象.keySet.stream();
               集合对象.entrySet().stream();
       数组
               Arrays中的静态方法stream生成流
               Arrays.stream(数据名)；
       同种数据类型得多个数据
               1,2,3,4,5....
               "aaa","bbb","ccc"...
               使用Stream.of(T...values)生成流
               Stream.of(数据1,数据2,数据3,...);

public class test1 {
            public static void main(String[] args) {
                //单列集合
                ArrayList<String> list=new ArrayList<>();
                list.add("aaa");
                list.add("abc");
                list.add("acb");
                Stream<String> stream = list.stream();
                stream.forEach(s-> System.out.println(s));
                //双列集合
                //不能直接获得stream流  keyset  先获得所有的键  再把所有的键放到Steam流中
                HashMap<String, Integer> hs=new HashMap<>();
                hs.put("zhangsan",23);
                hs.put("lisi",24);
                hs.put("wangwu",25);
                hs.keySet().stream().forEach(s -> System.out.println(s));
        
                //entry
                //先获得所有键值对对象
                //再把Set集合中所有的键值对对象放到Stream流中
                hs.entrySet().stream().forEach(s-> System.out.println(s));
        
                //数组
                int[] arr={1,2,3,4,5};
                Arrays.stream(arr).forEach(s-> System.out.println(s));
        
                //同种类型的多个数据
                Stream.of(1,2,3,4,5,6).forEach(s-> System.out.println(s));
            }
        }

   Stream流的常见中间操作方法
       Stream<T> filter(Predicate predicate):用于对六种的数据进行过滤
           Predicate接口中的方法
           boolean test(T t); 对给定的参数进行判断，返回一个布尔值
       代码实例：

public class test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张四疯");
        list.add("张五");
        list.add("赵六");
        list.add("王七");

        //filter 方法获取流中的每一个数据
        //而test的方法中的s，就依次表示流中的每一个数据
        //我们只要再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));
        
                //因为Predicate接口中只有一个抽象方法test  所以我们可以使用test来简化
        //        list.stream().filter(
        //                (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));
    }
}

Stream流的常见中间方法操作
Stream<T> limit(long maxSize);截取指定参数个数的数据
Stream<T> skip(long n);跳过指定参数个数的数据
static<T> Stream<T> concat(Stream a,Stream b);合并a,b两个流为一个
Stream<T> distinct(); 去除流中重复的元素，依赖(hashCode和equals方法)
代码：

public class test {
            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(2).forEach(s-> System.out.println(s));
                //Stream<T> skip(long n);跳过指定参数个数的数据
                list.stream().skip(2).forEach(s-> System.out.println(s));
                //static<T> Stream<T> concat(Stream a,Stream b);合并a,b两个流为一个
                ArrayList<String> list2 = new ArrayList<>();
                list.add("张丰");
                list.add("张疯");
                list.add("张");
                list.add("赵");
                list.add("王");
        
                Stream<String> stream = list.stream();
                Stream<String> stream1 = list2.stream();
                Stream<String> concat = Stream.concat(stream1, stream1);
                concat.forEach(s-> System.out.println(s));
                //简化版
                Stream.concat(list.stream(), list2.stream()).forEach(s-> System.out.println(s));
                //Stream<T> distinct(); 去除流中重复的元素，依赖(hashCode和equals方法)
                list.stream().distinct().forEach(s-> System.out.println(s));
            }
        }

   Stream流的终结方法
   void forEach(Consumer action);对此流的每个元素执行操作
           Consumer接口中的方法 void accept(T t);对给定的参数执行此操作
   long count();返回此流中的元素数
   public class test {
           public static void main(String[] args) {
               ArrayList<String> list = new ArrayList<>();
               list.add("张三丰");
               list.add("张四疯");
               list.add("张五");
               list.add("赵六");
               list.add("王七");
               //void forEach(Consumer action);对此流的每个元素执行操作
               //Consumer接口中的方法 void accept(T t);对给定的参数执行此操作
               //在forEach方法的底层，会循环获取到流中的每一个数据
               //并循环调用accept方法，并把每一个数据换地给accept方法
               //s表述流中每一个数据，我们只需要在accept方法中，写上处理的业务逻辑就可以了
               // list.stream().forEach(new Consumer<String>() {
               // @Override
               // public void accept(String s) {
               // System.out.println(s);
               // }
               // });
               //简化版因为Consumer接口中，只有一个accept方法
               list.stream().forEach(s-> System.out.println(s));
               //   long count();返回此流中的元素数
               long count = list.stream().count();
               System.out.println(count);

           }
       }
       Stream流的收集操作
       R collectors(Collectors collector)

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

 public class test2 {
            public static void main(String[] args) {
                ArrayList<Integer> list=new ArrayList<>();
                for (int i = 1; i <10; i++) {
                    list.add(i);
                }
                
                list.add(1);
                list.add(2);
                //filter  负责过滤数据  collect  负责收集数据
                //获取流中剩余的数据，但是他不负责创建容器，也不负责把数据添加到容器中
                //Collectors.toList())  创建一个List集合，并把所有的集合添加到List集合中
                List<Integer> collect = list.stream().filter(s -> s % 2 == 0).collect(Collectors.toList());
                System.out.println(collect);
        
                Set<Integer> collect1 = list.stream().filter(s -> s % 2 == 0).collect(Collectors.toSet());
                System.out.println(collect1);
            }
        }

   Map练习：
       创建一个ArrayList集合，添加字符串，和数字，保留数字大于10的并将结果收集到Map集合中，字符串为键，年龄为值
   代码：

public class test3 {
            public static void main(String[] args) {
            ArrayList<String>  list=new ArrayList<>();
            list.add("zhangsan,23");
            list.add("lisi,25");
            list.add("wangwu,19");
            list.add("zhaoliu,18");
        
                Map<String, Integer> collect = list.stream().filter((String s) -> {
                    String[] split = s.split(",");
                    int anInt = Integer.parseInt(split[1]);
                    return anInt > 20;
                }
                //collect方法只能获取到流中剩余的每一个数据
                        //让底层不能创建容器  也不能把数据添加到容器中
                        //s依次表示流中每一个数据
                        //第一个lambda表达式就是如何获取到Map的值
                        //第二个Lambda表达式就是如何获取到Map的值
        
                ).collect(Collectors.toMap(
                        (String s) -> {
                            return s.split(",")[0];
                        },
                        (String s) -> {
                            return Integer.parseInt(s.split(",")[1]);
                        }
                ));
        
                System.out.println(collect);
            }
        }

因为最近在加班，每天就三个小时左右，做的笔记比较潦草，希望多多包涵QAQ