Stream流

Stream将要处理的元素集合看作一种流,在流的过程中,借助Stream API对流中的元素进行操作

1.创建流

        //方法一.Collection.stream() 方法用集合创建流
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        HashSet<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        HashMap<String, String> map = new HashMap<>();
        Stream<String> stream3 = map.keySet().stream();
        Stream<String> stream4 = map.values().stream();
        Stream<Map.Entry<String, String>> stream5 = map.entrySet().stream();

        //方法二.Arrays.stream(T[] array)方法用数组创建流
        String[] array={"aa","bb","cc"};//注意:基本数据类型的数组会将整个数组看做一个元素进行操作
        Stream<String> stream6 = Arrays.stream(array);

        //方法三.stream中的静态方法of获取流
        Stream<String> stream7 = Stream.of("aa", "bb", "cc");

        String[] strings={"aa","bb","cc"};
        Stream<String> stream8 = Stream.of(strings);

2.stream流常用方法
注意:一个流只能操作一遍

数据:

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"如来佛主","猪八戒","孙悟空","沙僧","唐僧");

forEach方法

        list.stream().forEach((String str)->{
            System.out.println(str);
        });
        //简化Lambda
        list.stream().forEach(str-> System.out.println(str) );
        //再简化,转化为方法引用
        list.stream().forEach(System.out::println);

count方法

        long count = list.stream().count();
        System.out.println(count);

filter方法

 //得到名字长度为3的人
        list.stream().filter((String s)->{
            return s.length()==3;
        }).forEach(System.out::println);
        //简化lambda表达式
        list.stream().filter(s->s.length()==3).forEach(System.out::println);

limit方法

list.stream().limit(3).forEach(System.out::println);//获取前三个

skip方法

list.stream().skip(2).forEach(System.out::println);//跳过前两个

map方法:将一种类型的流转化为另一种类型的流

        Stream<String> stream = Stream.of("11", "12", "13");
       stream.map((String s)->{
            return Integer.parseInt(s);
        }).forEach(System.out::println);
        //简化lambda
        stream.map(s->(Integer.parseInt(s))).forEach(System.out::println);
        //再简化
        stream.map(Integer::parseInt).forEach(System.out::println);

sorted方法

Stream<Integer> stream2 = Stream.of(12, 11, 16);
        //默认排序规则,升序
        stream2.sorted().forEach(System.out::println);
        //指定排序规则,指定降序
        Stream<Integer> stream3 = Stream.of(12, 11, 16);
/*        stream3.sorted((Integer i1,Integer i2)->{
            return i2-i1;
        }).forEach(System.out::println);*/
        //简化
        stream3.sorted((i1,i2)->i2-i1).forEach(System.out::println);

distinct方法:去除重复
注意:自定义对象去除重复需重写equals方法和hashCode方法

        Stream<Integer> stream4 = Stream.of(12,16, 11, 16);
        stream4.distinct().forEach(System.out::println);

match方法

        Stream<Integer> stream5 = Stream.of(12, 11, 16);
        //boolean b1 = stream5.allMatch(i -> i > 0);//所有元素都满足田间
        //boolean b2 = stream5.anyMatch(i -> i > 12);//只要有一个元素满足条件
        boolean b3 = stream5.noneMatch(i -> i < 0);//所有元素都不满足条件

find方法:找到第一个元素

        Stream<Integer> stream6 = Stream.of(12, 11, 16);
        Optional<Integer> optional = stream6.findFirst();
        //Optional<Integer> optional1 = stream5.findAny();
        System.out.println(optional.get());

min,max方法

        Stream<Integer> stream7 = Stream.of(12, 11, 16);
/*        Optional<Integer> max = stream7.max((i1, i2) -> i1 - i2);
        System.out.println("max = " + max.get());*/
        Optional<Integer> min = stream7.min((i1, i2) -> i1 - i2);
        System.out.println("min = " + min.get());

reduce方法:将所有数据归纳得到一个数据

        //举例一:求和
        Stream<Integer> stream8 = Stream.of(12, 11, 16);
        int reduce = stream8.reduce(0, (x, y) -> {
            return x + y;
        });
        System.out.println("reduce = " + reduce);
        //举例二:求最大值
/*        int reduce2 = stream8.reduce(0, (x, y) -> {
            return x > y ? x : y;
        });
        System.out.println("reduce2 = " + reduce2);*/

concat方法:合并为一个流

        Stream<Integer> streamA = Stream.of(1, 2);
        Stream<Integer> streamB = Stream.of(3, 4);
        Stream.concat(streamA, streamB).forEach(System.out::println);
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LeBron永鑫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值