Stream流常用方法

最新推荐文章于 2024-10-02 21:11:15 发布
最新推荐文章于 2024-10-02 21:11:15 发布
阅读量1.9k 收藏 34
点赞数 4
分类专栏： JavaSE进阶 文章标签： html5 经验分享 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58398160/article/details/119986012
版权

1.Stream流的常用方法：

      终结方法：返回值类型不再是Stream接口本身类型的方法，例如：forEach方法和count方法
      非终结方法/延迟方法：返回值类型仍然是Stream接口自身类型的方法，除了终结方法都是延迟方法。例如：filter,limit,skip,map,concat
      方法名               方法的作用             方法的种类               是否支持链式调用
      count                 统计个数                     终结                               否
      foEach               逐一处理                     终结                               否
      filter                   过滤                         函数拼接                           是
      limit                   取用前几个              函数拼接                            是
      skip                   跳过前几个              函数拼接                            是
      map                      映射                     函数拼接                            是
      concat                   组合                    函数拼接                            是

2.count方法：

      long count();   统计流中的元素，返回long类型数据
public class Tests_count {
    public static void main(String[] args) {
        /*
        * count方法：
        *       long count();   统计流中的元素，返回long类型数据
        *
        * */
        // 创建List集合
        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);
    }
}

3.forEach

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

public class Tests_forEach {
    public static void main(String[] args) {
    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);
        });
        /*
        * 虽然方法名称叫做【forEach】，但是与for循环中的【for-each】昵称不同，该方法并不保证元素的逐一消费动作在流中是被有序执行的
        * */
        System.out.println("==========================");
        // parallelStream()方法可以得到并行流
        list.parallelStream().forEach((String name)->{
            System.out.println(name);
        });
    }
}

4.filter方法

      Stream<T> filter(Predicate<? super T> predicate);  过滤出满足条件的元素
          参数Predicate：函数式接口，抽象方法：boolean test(T t);
          Predicate接口：是一个判断接口

public class Tests_filter {
    public static void main(String[] args) {


        // 获取stream流
        Stream<String> stream = Stream.of("张三", "张三四", "王五", "赵六", "张三三", "周八");
        // 需求：过滤处
        stream.filter((String name)->{
            return name.startsWith("张");
        }).forEach((String name)->{
            System.out.println(name);
        });
    }
}

5.limit方法

      Stream<T>
      注意：
      参数是一个long类型，如果流的但钱长度大于参数则进行截取；否则不进行操作

public class Tests_limit {
    public static void main(String[] args) {

        // 获取stream流
        Stream<String> stream = Stream.of("张三", "张三四", "王五", "赵六", "张三三", "周八");
        // 需求：保留前3个元素
        stream.limit(3).forEach((String name) -> {
            System.out.println(name);
        });
        System.out.println("===========================");
        // 如果流的获取长度 大于 流当前的长度，则不操作

        stream.limit(10).forEach(name-> System.out.println(name)); // 异常： stream has already
                                                // been operated upon or closed 流已被操作或关闭

        Stream<String> stream1 = Stream.of("张三", "张三四", "王五", "赵六", "张三三", "周八");
        stream1.limit(10).forEach(name-> System.out.println(name));
        
    }
}

6.skip方法：

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

public class Tests_skip {
    public static void main(String[] args) {

        // 获取stream流
        Stream<String> stream = Stream.of("张三", "张三四", "王五", "赵六", "张三三", "周八");
        // 需求：跳过前3个
        stream.skip(3).forEach(name-> System.out.println(name));
    }
}

7.map方法

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

public class Tests_map {
    public static void main(String[] args) {


        // 获取stream流
        Stream<String> stream1 = Stream.of("11", "22", "33", "44", "55");
        // 需求：把stream1流中的元素转换为int类型
        stream1.map((String s)-> Integer.parseInt(s)).forEach((Integer i)->System.out.println(i));

        // 需求：把stream2流中的元素转换为String类型
        Stream<String> stream2 = Stream.of("11", "22", "33", "44", "55");
        stream2.map((String s) ->
        {return s+"";   // 将流中的String类型的元素进行加工，拼接操作，返回String类型的元素的流
        }).forEach(s -> {
            System.out.println(s);});   // 将流中的String类型元素逐一输出

    }
}

8.concat方法

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

public class Tests_concat {
    public static void main(String[] args) {


        Stream<String> stream1 = Stream.of("张三", "张三四", "王五", "赵六", "张三三", "周八");
        Stream<String> stream2 = Stream.of("11", "22", "33", "44", "55");
        // 需求：合并两个流
        Stream<String> concat = Stream.concat(stream1, stream2);
        concat.forEach(name-> System.out.println(name));
    }
}

9.收集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集合

public class Tests {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张三四");
        list.add("王五");
        list.add("赵六");
        list.add("张三三");
        list.add("周八");
        // 需求：过滤出姓张的并且长度为3的元素

        Stream<String> stream1 = list.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3);

        // stream 收集到单列集合中
        List<String> list1 = stream1.collect(Collectors.toList());
        System.out.println(list1);

        // stream 手机到单列集合中
        Set<String> set1 = stream1.collect(Collectors.toSet());
        System.out.println(set1);
    }
}

Stream流中一个方法
      Object[] toArray(); 返回一个包含此流的元素的数组

public class Tests2 {
    public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张三四");
        list.add("王五");
        list.add("赵六");
        list.add("张三三");
        list.add("周八");
        Stream<String> stream = list.stream().filter(name -> name.length() == 3).filter(name -> name.startsWith("张"));
        // 将stream流中的元素转成Array数组对象
        Object[] arr = stream.toArray();
        System.out.println(Arrays.toString(arr));
    }
}

stream流常用方法
weixin_68383613的博客
10-24 126
stream流常用方法处理集合
Java8 Stream流 常用方法
林临的博客
08-27 360
需要先掌握 1.Lambda 表达式 菜鸟教程 Lambda 表达式，也可称为闭包，它是 Java 8 的重要新特性。 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 以下是lambda表达式的重要特征: 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表
Stream流的常用方法大全
weixin_52317961的博客
12-06 2万+
Stream流常用方法
Stream流的中间方法
最新发布
程小白的博客
10-02 457
【代码】Stream流的中间方法。
Stream流中的常用方法
weixin_44548893的博客
08-16 366
Stream流中的常用方法_forEach、_filter、_map、_count、_limit、_skip、_concat Stream流中的常用方法_forEach /* Stream流中的常用方法_forEach void forEach(Consumer<? super T> action); 该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。 Consumer接口是一个消费型的函数式接口,可以传递Lambda表达式,消费数据 简单记: forEach方
stream流的常用方法
qq_44306975的博客
12-21 673
stream流用法的总结
玩转 Java8 Stream 流，常用方法，详细用法大合集
m0_74931226的博客
11-13 497
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。特点：不是数据结构，不会保存数据。不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（保留意见：毕竟peek方法可以修改流中元素）
Stream流的常用方法
热门推荐
DQ6667的博客
04-11 4万+
1、快速创建List List list = Stream.of("1", "2").collect(Collectors.toList()); 2、取对象的某一列 低效方式： List<String> userNameList = new ArrayList<>(); for (String) List<String> userNameList = list.stream().map(User::getName).collect(Collectors.toList(
stream流最常用方法
leese233的博客
02-21 667
stream流最常用方法
Stream流的常用方法 总结
clamming_rapper的博客
12-30 615
stream流的常用方法
Stream流及常用方法
zezea的博客
01-13 6083
Stream流及常用方法 Stream流 java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。） 特点： 1.Stream流是一个集合元素的函数模型，其本身并不存储任何元素或地址值 2.Stream流是JDK1.8之后出现的，具有更优雅的书写方式。 3.中间操作都会返回流对象本身，这样多个操作可以串联成一个管道。可以对操作进行优化，比如延...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值