java——Stream流

最新推荐文章于 2024-05-31 10:46:10 发布

m0_70954783

最新推荐文章于 2024-05-31 10:46:10 发布

阅读量74

点赞数

文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/m0_70954783/article/details/130175249

版权

Stream流

将list集合中姓张的过滤到另外一个新的集合中

public class Demo1 {
    public static void main(String[] args) {
        //将list集合  姓张的过滤到另外一个新的集合中
        //然后再将新集合中的名字的长度为3的存到新的集合中
        List<String> list = new ArrayList<>();
        list.add("老邢");
        list.add("张得帅");
        list.add("张飞");
        list.add("张开放");
        list.add("蔡徐坤");
        List<String> list1 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
               list1.add(s);
            }

        }
        System.out.println(list1);
        List<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if(s.length() == 3) {
                list2.add(s);
            }
        }
        System.out.println(list2);
    }
}

stream流写法

list.stream(). 把一个集合变成Stream流
filter((name)->name.startsWith("张")). 过滤 姓张
filter((name)->name.length() == 3).过滤长度为3 的
forEach((name)-> System.out.println(name));  遍历

获取Stream对象

可以根据集合获取流对象

就是将集合中的数据变成了流的形式

1.根据List集合获取流对象

ArrayList<String> strings = new ArrayList<>();
     strings.add("狗蛋");
     strings.add("老邢");
     strings.add("二贝");
     System.out.println(strings);
     //可以list集合变成一个流对象
     Stream<String> stream = strings.stream();
     System.out.println(stream);//内存地址

2.根据Set集合获取流对象

Set<String> sets = new HashSet<>();
     sets.add("头疼");
     sets.add("腰疼");
     sets.add("哪都疼");
     Stream<String> stream1 = sets.stream();
     System.out.println(stream1);

3.根据map集合获取对象

Map<String, String> maps = new HashMap<>();
        maps.put("1", "黄焖鸡");
        maps.put("2", "酸菜鱼");
        maps.put("3", "酱牛肉");
        //map集合没有stream方法，转为集合再来操作
        Set<String> strings1 = maps.keySet();
        Stream<String> stream2 = strings1.stream();
        Collection<String> values = maps.values();
        Stream<String> stream3 = values.stream();
        Set<Map.Entry<String, String>> entries = maps.entrySet();
        Stream<Map.Entry<String, String>> stream4 = entries.stream();

4.数组

String[] arr = {"a", "b"};
        //数组也可以变成stream流形式的
        Stream<String> arr1 = Stream.of(arr);

Stream流对象下面的方法

方法的名字	方法的作用	方法的种类	是否支持链式操作
count	统计个数	终结方法	否
forEach	遍历数据	终结方法	否
filter	过滤数据	可以拼接	是
limit	取前几个数据	可以拼接	是
skip	跳过前几个数据	可以拼接	是
map	映射方法	可以拼接	是
concat	拼接	可以拼接	是

各方法的用法

count和forEach

count：统计流中的个数，返回值是long类型的数据

forEach：遍历流中数据

public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        Stream<String> stream = strings.stream();
        long count = stream.count();
        System.out.println(count);
        //链式操作
        long count1 = strings.stream().count();
        System.out.println(count1);
        //froEach
        //对此流的每个元素执行操作
        strings.stream().forEach(new Consumer<String>() {
            @Override
            //将流中的数据 赋值 s
            public void accept(String s) {
                System.out.println(s);
            }
        });
        strings.stream().forEach((s)-> System.out.println(s));

    }
}

filter方法

filter：过滤流中的数据

public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        strings.add("杨坤");
        strings.add("陈坤");

        strings.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                //s流中字符串每个的数据
                boolean b = s.endsWith("坤");

                return b;
            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                boolean c = s.startsWith("陈");
                return c;
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        strings.stream().filter((goudan)->goudan.endsWith("坤")).filter((s)->s.startsWith("陈")).forEach((s)-> System.out.println(s));
    }
}

limit方法

limit：限制输出，取流中的前几个数据

public class Demo5 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        strings.add("杨坤");
        strings.add("陈坤");
        strings.add("战三坤");
        strings.add("损五坤");
        strings.add("爱坤");
        //limit 是要前几个数据 根据参数不同
        strings.stream().limit(5).forEach((s)-> System.out.println(s));
        strings.stream().limit(5).filter((s)->s.endsWith("坤")).forEach((s)-> System.out.println(s));
    }
}

map方法

map：处理映射关系的

public class Demo6 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("12");
        strings.add("13");
        strings.add("14");
        strings.add("15");
        //将字符串数字 转为int类型的数据
//        for (String string : strings) {
//
//            int i = Integer.parseInt(string);
//            System.out.println(i);
//        }
        strings.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                int i = Integer.parseInt(s);
                return i;
            }
        }).forEach((Integer s)-> System.out.println(s));

        strings.stream().map((s)->Integer.parseInt(s)).forEach((s)-> System.out.println(s));

    }
}

skip方法

skip：跳过流中的前几个值

public class Demo7 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("12");
        strings.add("13");
        strings.add("14");
        strings.add("15");
        strings.stream().skip(2).forEach((s)-> System.out.println(s));
        
    }
}

concat合并两个流

public class Demo8 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("12");
        list1.add("13");
        list1.add("14");
        list1.add("15");
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        strings.add("杨坤");
        Stream<String> stream = list1.stream();
        Stream<String> stream1 = strings.stream();
        //将两个流合并
        Stream<String> concat = Stream.concat(stream, stream1);
        concat.forEach((s)-> System.out.println(s));
    }
}

收集流

stream.collect(Collectors.toList())
stream.collect(Collectors.toSet())
toList();   将流转为List集合
toSet();   将流转为Set集合

流只是中间处理数据的，最后要把流转为集合之后再去使用

public class Demo9 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        strings.add("杨坤");
        strings.add("陈坤");
        strings.add("战三坤");
        strings.add("损五坤");
        strings.add("爱坤");
        strings.add("爱坤");
        //collect  收集的方法
        //stream.collect(Collectors.toList()) 以什么样的方式收集
        List<String> list = strings.stream().filter((s) -> s.endsWith("坤")).skip(2).collect(Collectors.toList());
        System.out.println(list);
        Set<String> set = strings.stream().filter((s) -> s.endsWith("坤")).skip(2).collect(Collectors.toSet());
        System.out.println(set);

    }
}