Stream流的常用方法

已于 2024-04-14 16:34:42 修改
阅读量411 收藏 3
点赞数
文章标签： java 开发语言 java18 stream
于 2023-08-19 23:12:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_2662385590/article/details/132385605
版权

前言

使用Stream流的时候一定要注意判断是否null。

forEach遍历

forEach:该方法接收一个Consumer接口函数，将每一个流元素交给该函数处理forEach方法：用来遍历流中的数据
注：是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法

public class Stream_ForEach {
    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String>stream= Stream.of("张三","李四","王五","赵六");
        //使用Stream流的方法forEach对stream流中的数据遍历
        //遍历stream1
        stream1.forEach((name)-> System.out.println(name));
        //输出stream2
        //stream1.stream().forEach(System.out::println);
    }
}
结果：
张三
李四
王五
赵六

filter过滤

filter：用于对Stream流中的数据进行过滤
filter(Predicate<? super T>predicate)
filter方法的参数Predicate是一个函数式接口，可以使用lambda表达式
Predicate中的抽象方法
boolean test（T t）

public class Stream_filter {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六1", "田七", "田七1");
 
        //单条件过滤
        Stream<String> stream1 = stream.filter((String name) -> {
            return name.startsWith("田");
        });
        //遍历stream1
        stream1.forEach((name)-> System.out.println(name));    
    }
}
结果：
田七
田七1

distinct去重

public class Stream_distinct {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream = Stream.of("张三", "张三","张三","李四", "王五", "赵六", "田七");
        //去重
        List<String> stream1 = stream.distinct().collect(Collectors.toList());
        //输出stream1
        System.out.println(stream1)
    }
}
结果：[张三, 李四, 王五, 赵六, 田七]

limit截取

limit:用于截取流中的元素
limit可以对流进行截取，只取用前n个
limit（long maxSize）;
参数是一个long型，如果集合当前长度大于参数则进行截取，否则不进行操作
limit是一个延迟方法，可以继续使用Stream流方法

public class Stream_limit {
    public static void main(String[] args) {
        //创建一个集合
        ArrayList<String> list = new ArrayList<>(Arrays.asList("张三", "张三","张三","李四", "王五", "赵六1", "田七"));
        //截取去重后的前2个元素
        List<String> collect = list.stream().limit(2).collect(Collectors.toList());
        //输出stream1
        System.out.println(collect);
    }
}
结果：[张三, 张三]

skip跳过

skip方法：用于跳过元素
skip(long n)
如果流的当前长度大于n，则跳过前n个，否则将会得到一个长度为0的空流

public class Stream_skip {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream = Stream.of("张三","李四", "王五", "赵六", "田七");
        //跳过去重后的前2个元素
        List<String> collect = stream.skip(2).collect(Collectors.toList());
        //输出stream1
        System.out.println(collect);
    }
}
结果：[王五, 赵六, 田七]

排序sorted

public class Stream_sorted {
    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User(1,"张三",23));
        list.add(new User(2,"李四",18));
        list.add(new User(3,"王五",20));
        list.add(new User(4,"赵六",25));

        //根据年龄从小到大排序
        list = list.stream()
            .sorted(Comparator.comparing(User::getAge))
            .collect(Collectors.toList());
        list.forEach(System.out::println);
    }
}
结果：
User(id=2, name=李四, age=18)
User(id=3, name=王五, age=20)
User(id=1, name=张三, age=23)
User(id=4, name=赵六, age=25)

最值max,min

public class Stream_max_min {
    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User(1,"张三",23));
        list.add(new User(2,"李四",18));
        list.add(new User(3,"王五",20));
        list.add(new User(4,"赵六",25));
        //获取年龄最大的人
        User maxPeople = list.stream().max(Comparator.comparing(User::getAge)).get();

        //获取年龄最小的人
        User minPeople = list.stream().min(Comparator.comparing(User::getAge)).get();

        System.out.println(maxPeople);
        System.out.println(minPeople);
    }
}

统计reduce

public class Stream_reduce {
    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User(1,"张三",23));
        list.add(new User(2,"李四",18));
        list.add(new User(3,"王五",20));
        list.add(new User(4,"赵六",25));
        //计算所有用户的年龄的总和
        Integer reduce = list.stream().map(user -> user.getAge()).reduce(0, (a, b) -> a + b);

        System.out.println(reduce);
    }
}

List结构转换Map结构

把list信息转成map信息，方便使用k-v结构，使用其中ID，查询用户的全部信息，不用去遍历list取获取

public class Stream_list_to_map {
    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User(1,"张三",23));
        list.add(new User(2,"李四",18));
        list.add(new User(3,"王五",20));
        list.add(new User(4,"赵六",25));
        //方法一：List结构转换Map结构
        Map<Integer, User> userMap = list.stream().collect(Collectors.toMap(User::getId, user -> user));
    	//方法二：List结构转换Map结构
        Map<Integer, User> collect = list.stream().collect(Collectors.toMap(User::getId, Function.identity()));
        System.out.println(userMap);
    }
}

List对象转List
提取一个对象里面的数据，进行其他的操作（比如提取用户的ID，取查询关联的信息）

 
public class Stream_object_string {
    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User(1,"张三",23));
        list.add(new User(2,"李四",18));
        list.add(new User(3,"王五",20));
        list.add(new User(4,"赵六",25));

        //提取用户的ID
        List<Integer> collect = list.stream().map(User::getId).collect(Collectors.toList());

        System.out.println(collect);
    }
}

List对象转List

把一个list中的对象转成另一个list中的对象

public class Stream_object_object {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("张三",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("李四",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("王五",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //对象转对象
        List<Student> studentList = peopleList.stream().map(s->{
            return new Student(s.getName(),s.getAge());
        }).collect(Collectors.toList());
        System.out.println("value:"+studentList);
    }
}

anyMatch匹配

anyMatch()主要用于判断流中是否至少存在一个符合条件的元素，它会返回一个boolean值，并且对于它的操作， 一般叫做短路求值

public class Stream_anyMatch {
​
    public static void main(String[] args) {
        //判断集合中是否有年龄小于20的学生
        List<User> list = new ArrayList<>();
        list.add(new User(1,"张三",23));
        list.add(new User(2,"李四",18));
        list.add(new User(3,"王五",20));
        list.add(new User(4,"赵六",25));
        
        if(list.stream().anyMatch(user -> user.getAge() < 20)){
            System.out.println("集合中有年龄小于20");
        }else {
            System.out.println("集合中没有年龄小于20");
        }
    }
}

allMatch匹配

allMatch()的工作原理与anyMatch()类似，但是anyMatch执行时，只要流中有一个元素符合条件就会返回true， 而allMatch会判断流中是否所有条件都符合条件，全部符合才会返回true

public class Stream_allMatch {
​
    public static void main(String[] args) {
        //判断集合中所有的年龄是否都小于20
         List<User> list = new ArrayList<>();
        list.add(new User(1,"张三",23));
        list.add(new User(2,"李四",18));
        list.add(new User(3,"王五",20));
        list.add(new User(4,"赵六",25));
​
        if(list.stream().allMatch(user -> user.getAge() < 20)){
            System.out.println("集合所有的年龄都小于20");
        }else {
            System.out.println("集合中有年龄大于20的");
        }
    }
}
​

findAny查找

findAny用于获取流中随机的某一个元素，并且利用短路在找到结果时，立即结束

public class Stream_findAny {
    public static void main(String[] args) {
        //findAny用于获取流中随机的某一个元素，并且利用短路在找到结果时，立即结束
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三1","M",true));
        students.add(new Student(1,18,"张三2","M",false));
        students.add(new Student(1,21,"张三3","F",true));
        students.add(new Student(1,20,"张三4","F",false));
        students.add(new Student(1,20,"张三5","F",false));
        students.add(new Student(1,20,"张三6","F",false));
        Optional<Student> student1 = students.stream().filter(student -> student.getSex().equals("F")).findAny();
        System.out.println(student1.toString());
    }
}
结果：Optional[Student{id=1, age=21, name='张三3', sex='F', isPass=true}]
这里的结果是sex=F的第一个元素，当为串行流且数据较少时，获取的结果一般为流中第一个元素，但是当为并流行的时候，则会随机获取。

findFirst查找

findFirst使用原理与findAny类似，只是它无论串行流还是并行流都会返回第一个元素。

public class Stream_findFirst {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三1","M",true));
        students.add(new Student(1,18,"张三2","M",false));
        students.add(new Student(1,21,"张三3","F",true));
        students.add(new Student(1,20,"张三4","F",false));
        students.add(new Student(1,20,"张三5","F",false));
        students.add(new Student(1,20,"张三6","F",false));
        Optional<Student> student1 = students.stream().filter(student -> student.getSex().equals("F")).findFirst();
        System.out.println(student1.toString());
    }
}

收集齐中joining() 方法

public class Stream_joining {
    public static void main(String[] args) {
       List<String> list = Arrays.asList("Ram","Shyam","Shiv","Mahesh");
        String result = list.stream().collect(Collectors.joining());
        System.out.println(result);
        result = list.stream().collect(Collectors.joining(","));
        System.out.println(result);        
        result = list.stream().collect(Collectors.joining("-","[","]"));
        System.out.println(result);  
    }
}
运行结果为：
RamShyamShivMahesh
Ram,Shyam,Shiv,Mahesh
[Ram-Shyam-Shiv-Mahesh]

对集合按照单个属性分组、分组计数、排序Collectors.groupingBy（）

public class Stream_groupingBy {
    public static void main(String[] args) {
		Arrays.asList("apple", "apple", "banana", "apple", "orange", "banana", "papaya");
        // 分组
        Map<String, List<String>> result1 = items.stream().collect(Collectors.groupingBy(Function.identity()));
        System.out.println(result1);
    }
}
结果：//{papaya=[papaya], orange=[orange], banana=[banana, banana], apple=[apple, apple, apple]}

单个属性分组

public class Stream_groupingBy {
	 public static void main(String[] args) {
		User user1 = new User(1L,"zhangSan",23, "zs@qq.com", 1,1L);
        User user2 = new User(2L,"lisi",24, "ls@qq.com", 1,1L);
        User user3 = new User(3L,"wanger",23, "we@qq.com", 1,1L);
        User user4 = new User(4L,"zhaoliu",20, "zl@qq.com", 1,1L);
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        Map<Integer, List<User>> collect = list.stream().collect(Collectors.groupingBy(User::getAge));
        System.out.println(collect);
     }
}
结果：//{20=[User(id=4, name=zhaoliu, age=20, email=zl@qq.com, deleted=1, depId=1)], 23=[User(id=1, name=zhangSan, age=23, email=zs@qq.com, deleted=1, depId=1), User(id=3, name=wanger, age=23, email=we@qq.com, deleted=1, depId=1)], 24=[User(id=2, name=lisi, age=24, email=ls@qq.com, deleted=1, depId=1)]}

分组计数

public class Stream_groupingBy {
    public static void main(String[] args) {
		Arrays.asList("apple", "apple", "banana", "apple", "orange", "banana", "papaya");
        // 计数
        Map<String, Long> result2 = items.stream().collect(
                Collectors.groupingBy(
                        Function.identity(), Collectors.counting()
                )
        );  
        System.out.println(result1);
    }
}
结果：//{papaya=1, orange=1, banana=2, apple=3}
百事皆可乐~
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java8 Stream详解
HappyHeng的博客
10-16 2万+
Java8中提供了Stream对集合操作作出了极大的简化，学习了Stream之后，我们以后不用使用for循环就能对集合作出很好的操作。 一、流的初始化与转换：   Java中的Stream的所有操作都是针对流的，所以，使用Stream必须要得到Stream对象：   1、初始化一个流：     Stream stream = Stream.of("a", "b", "c");
Java 中 Stream 流的使用方法
qq_58417838的博客
12-25 1838
返回一个顺序流，即元素是按顺序处理的。这意味着对于大多数操作，它们将按照集合中元素的顺序依次执行。1.1、通过Collection对象的stream()或parallelStream()方法。1.4、通过IntStream、LongStream、DoubleStream接口中的of、1.3、通过Stream接口的of()、iterate()、generate()方法。使用一个终止操作来产生一个结果（新的对象）。该操作会强制之前的延迟操作立即执行，在此之后，该。操作是延迟执行的，会等到需要结果的时候才执行。
stream流的常用方法
weixin_44702189的博客
08-04 1万+
Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。Stream中间操作：·每次返回一个新的流，可以有多个。终端操作：每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。Streamstream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。stream不会改变数据源，通常情况下会产生一个新的集合或一个值。......
Java 8新特性Stream的常用方法总结和使用
最新发布
weixin_44625361的博客
05-28 809
Stream 是 Java 8 引入的一个新的流式处理 API，用于对集合进行高效的操作和处理。Stream 提供了一系列方法，使得对集合的操作更加简洁、高效和易于理解Stream API提供了一种高效且易于阅读的方式来操作数据，特别是在需要对数据进行过滤、映射、排序、聚合等操作时。
Stream流的三类方法
m0_72971266的博客
11-19 243
获取Stream流：创建一条流水线，并把数据放到流水线上准备进行操作中间方法：流水线上的操作。一次操作完毕之后，还可以继续进行其他操作。终结方法：一个Stream流只能有一个终结方法，流水线上的最后一个操作stream操作集合或者数组的第一步是先得到Stream流，然后才能使用流的功能。集合获取stream流的方式。
Java中的Stream流
qq_57689612的博客
10-28 3646
Java中Stream流用法; 主要是方便API使用等
Stream常用方法
qq_54571327的博客
10-31 416
Stream常用方法
Stream流常用方法
12-22
以下将详细介绍从标题和描述中提及的Stream流的常用方法： 1. **获取Stream流** - **从Collection获取**：所有实现了`Collection`接口的类（如`List`, `Set`, `Queue`等）都提供了`stream()`方法，用于将集合转换...
详解JAVA Stream流
08-18
Stream流提供了多种方法来处理数据，以下是一些常用的方法： 1. void forEach(Consumer<? super T> action)：该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。此方法为终结方法，遍历后不能...
Java Stream流知识总结
08-19
Java Stream流的常用方法： 1. filter()：用于对流元素进行过滤，例如 filter(s -> s.startsWith("张"))。 2. map()：用于对流元素进行转换，例如 map(s -> s.toUpperCase())。 3. sorted()：用于对流元素进行排序...
Java-IO流/Stream流总结
07-12
Java的IO流与Stream流是Java程序中处理输入输出的核心技术。IO流主要分为字节流和字符流，这两种流分别处理二进制数据（如图片、音频等）和文本数据（如ASCII、UTF-8编码的文本）。下面将详细阐述这两个流的分类、...
详解java8中的Stream数据流
08-29
Stream 的常用方法 * filter：筛选元素，返回满足条件的元素流。 * distinct：筛选重复的元素，返回一个元素流。 * skip：跳过指定数量的元素，返回一个流。 * limit：限制元素数量，返回一个流。 * map：将元素...
【JAVA基础之Stream流】掌握Stream流
2301_77358195的博客
05-06 547
Stream流可以让你通过链式操作对集合中的元素进行过滤、映射、排序、组合等操作，这些操作都是惰性执行的，只有在终端操作（如forEach、collect等）被调用时才会触发实际计算。Stream流可以简化代码并提高代码的可读性，同时也可以让编译器更好地进行优化，提高代码的执行效率。
Stream流式处理常见使用
weixin_43289848的博客
01-18 6354
java 8新特性 stream流式处理，提高代码整洁性
Stream流操作
weixin_43353685的博客
04-17 788
java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的Lambda，给我们操作集合（Collection）提供了极大的便利。那么什么是Stream？Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。中间操作，每次返回一个新的流，可以有多个。（筛选filter、映射map、排序sorted、去重组合skip—limit）终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。
Java8新特性：stream流应用，丢掉for循环实现复杂遍历功能
鳄鱼儿
12-02 2677
到此，基础Stream用户就已经说完了，看到这里我们会发现，所以的stream其实都可以用for循环来实现，而我们全篇都没有使用for循环来实现，这些如果用for循环实现，你会发现实现的语句变得复杂了很多，不信的话，你可以试试。我们也可以看到stream带来的好处，包括代码更简洁、解耦等。
Java>Stream流中的常用方法>>forEach、filter、map、count、limit、skip、concat方法的使用
越努力，越幸福！
08-20 1万+
Stream流中的常用方法： 逐一处理：forEach 过滤：filter 映射：map 统计个数：count 取用前几个：limit 跳过前几个：skip 组合：concat 逐一处理：forEach package JDK8.Xin.Demo01Stream; import java.util.stream.Stream; /* Stream流中的常用方法_for...
Stream中关于collect方法的介绍
热门推荐
第二庄
06-15 4万+
在Stream 的API中可以查到有两种collect方法，分别是： 第一种： &lt;R, A&gt; R collect(Collector&lt;? super T, A, R&gt; collector); 第二种： &lt;R&gt; R collect(Supplier&lt;R&gt; supplier, BiConsumer&lt;R, ? super T&gt; ...
使用Stream流来实现遍历
li237的博客
08-04 2575
package File04; import java.util.ArrayList; import java.util.List; public class demo02 { public static void main(String[] args) { List list= new ArrayList(); list.add(“张三丰”); list.add(“张锤”); list.stream() //fileter中的参数是一个Predicate函数式接口，所以这里使用lambda表达式 .fil
stream流常用方法
05-01
Stream流常用方法有以下几种： 1. filter()：过滤满足条件的元素。 2. map()：对每个元素进行转换操作，从一个值转换成另一个值。 3. forEach()：遍历Stream流中的每个元素，进行处理，如输出、修改等。 4. sorted...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值