Java8的 Stream 流学习与使用总结

最新推荐文章于 2023-03-24 11:32:45 发布
最新推荐文章于 2023-03-24 11:32:45 发布
阅读量693 收藏 5
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43927773/article/details/108367054
版权

1. Stream 流介绍

Stream的原理：将要处理的元素看做一种流，流在管道中传输，并且可以在管道的节点上处理，包括过滤筛选、去重、排序、聚合等。元素流在管道中经过中间操作的处理，最后由最终操作得到前面处理的结果。
Stream 流的使用总是按照一定的步骤进行，可以抽象出下面的使用流程。
数据源 -> 数据处理/转换-> 结果处理

1.1. 数据源

数据源也就是数据的来源，可以通过多种方式获得 Stream 数据源，下面列举几种常见的获取方式。
• Collection.stream(); 从集合获取流。
• Collection.parallelStream(); 从集合获取并行流。
• Arrays.stream(T array) or Stream.of(); 从数组获取流。
• BufferedReader.lines(); 从输入流中获取流。
• IntStream.of() ; 从静态方法中获取流。
• Stream.generate(); 自己生成流

1.2. 数据处理

数据处理/转换步骤可以有多个操作，这步也被称为中间操作。数据处理演示。

@Test
public void streamDemo(){
    List<String> nameList = Arrays.asList("Darcy", "Chris", "Linda", "Sid", "Kim", "Jack", "Poul", "Peter");
    // 1. 筛选出名字长度为4的
    // 2. 名字前面拼接 This is
    // 3. 遍历输出
    nameList.stream()
            .filter(name -> name.length() == 4)
            .map(name -> "This is "+name)
            .forEach(name -> System.out.println(name));
}
// 输出结果
// This is Jack
// This is Poul

数据处理/转换操作有 map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered 等。

1.3. 收集结果

结果处理是流处理的最后一步，执行完这一步之后流会被彻底用尽，流也不能继续操作了。
常见的结果处理操作有 forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator 等。
下面演示了简单的结果处理的例子。

/**
 *  转换成为大写然后收集结果，遍历输出
 */
@Test
public void toUpperCaseDemo() {
    List<String> nameList = Arrays.asList("Darcy", "Chris", "Linda", "Sid", "Kim", "Jack", "Poul", "Peter");
    List<String> upperCaseNameList = nameList.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
    upperCaseNameList.forEach(name -> System.out.println(name + ","));
}
// 输出结果
// DARCY,CHRIS,LINDA,SID,KIM,JACK,POUL,PETER,

2. Stream 流使用

Stream 流在使用时候总是借助于 Lambda 表达式进行操作，Stream 流的操作也有很多种方式，下面列举的是常用的一些操作。

2.1. Stream 流获取

获取 Stream 的几种方式在上面的 Stream 数据源里已经介绍过了，下面是针对上面介绍的几种获取 Stream 流的使用示例。

@Test
public void createStream() throws FileNotFoundException {
    List<String> nameList = Arrays.asList("Darcy", "Chris", "Linda", "Sid", "Kim", "Jack", "Poul", "Peter");
    String[] nameArr = {"Darcy", "Chris", "Linda", "Sid", "Kim", "Jack", "Poul", "Peter"};
    // 集合获取 Stream 流
    Stream<String> nameListStream = nameList.stream();
    // 集合获取并行 Stream 流
    Stream<String> nameListStream2 = nameList.parallelStream();
    // 数组获取 Stream 流
    Stream<String> nameArrStream = Stream.of(nameArr);
    // 数组获取 Stream 流
    Stream<String> nameArrStream1 = Arrays.stream(nameArr);
    // 文件流获取 Stream 流
    BufferedReader bufferedReader = new BufferedReader(new FileReader("README.md"));
    Stream<String> linesStream = bufferedReader.lines();
    // 从静态方法获取流操作
    IntStream rangeStream = IntStream.range(1, 10);
    rangeStream.limit(10).forEach(num -> System.out.print(num+","));
    System.out.println();
    IntStream intStream = IntStream.of(1, 2, 3, 3, 4);
    intStream.forEach(num -> System.out.print(num+","));
}

2.2. forEach

forEach 是 Stream 流中的一个重要方法，用于遍历 Stream 流，它支持传入一个标准的 Lambda 表达式。但是它的遍历不能通过 return/break 进行终止。同时它也是一个 terminal 操作，执行之后 Stream 流中的数据会被消费掉。

List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
numberList.stream().forEach(number -> System.out.println(number+","));
// 输出结果
// 1,2,3,4,5,6,7,8,9,

2.3. map / flatMap（转换）

使用 map 把对象一对一映射成另一种对象或者形式。

/**
 * 把数字值乘以2
 */
@Test
public void mapTest() {
    List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    // 映射成 2倍数字
    List<Integer> collect = numberList.stream()
            .map(number -> number * 2)
            .collect(Collectors.toList());
    collect.forEach(number -> System.out.print(number + ","));
    System.out.println();

    numberList.stream()
            .map(number -> "数字 " + number + ",")
            .forEach(number -> System.out.println(number));
}
// 输出结果
// 2,4,6,8,10,12,14,16,18,
// 数字 1,数字 2,数字 3,数字 4,数字 5,数字 6,数字 7,数字 8,数字 9,

再比如：

  public static void main(String [] args) {

        Student s1 = new Student(1L, "肖战", 15, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "杨紫", 17, "北京");
        Student s4 = new Student(4L, "李现", 17, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);

        testMap(students);
    }

    /**
     * 集合转换
     * @param students
     * @return
     */
    private static void testMap(List<Student> students) {
        //在地址前面加上部分信息，只获取地址输出
        List<String> addresses = students.stream().map(s ->"住址:"+s.getAddress()).collect(Collectors.toList());
        addresses.forEach(a ->System.out.println(a));
    }

运行结果

map就是将对应的元素按照给定的方法进行转换。

上面的 map 可以把数据进行一对一的映射，而有些时候关系可能不止 1对 1那么简单，可能会有1对多。这时可以使用 flatMap。下面演示使用 flatMap把对象扁平化展开。

/**
 * flatmap把对象扁平化
 */
@Test
public void flatMapTest() {
    Stream<List<Integer>> inputStream = Stream.of(
            Arrays.asList(1),
            Arrays.asList(2, 3),
            Arrays.asList(4, 5, 6)
    );
    List<Integer> collect = inputStream
            .flatMap((childList) -> childList.stream())
            .collect(Collectors.toList());
    collect.forEach(number -> System.out.print(number + ","));
}
// 输出结果
// 1,2,3,4,5,6,

2.4. filter（筛选）

使用 filter 进行数据筛选，挑选出想要的元素，下面的例子演示怎么挑选出偶数数字。

/**
 * filter 数据筛选
 * 筛选出偶数数字
 */
@Test
public void filterTest() {
    List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    List<Integer> collect = numberList.stream()
            .filter(number -> number % 2 == 0)
            .collect(Collectors.toList());
    collect.forEach(number -> System.out.print(number + ","));
}

得到如下结果。

2,4,6,8,

再比如：

public static void main(String [] args) {

        Student s1 = new Student(1L, "肖战", 15, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "杨紫", 17, "北京");
        Student s4 = new Student(4L, "李现", 17, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);

        List<Student> streamStudents = testFilter(students);
        streamStudents.forEach(System.out::println);
    }
    /**
     * 集合的筛选
     * @param students
     * @return
     */
    private static List<Student> testFilter(List<Student> students) {
        //筛选年龄大于15岁的学生
//        return students.stream().filter(s -> s.getAge()>15).collect(Collectors.toList());
        //筛选住在浙江省的学生
        return students.stream().filter(s ->"浙江".equals(s.getAddress())).collect(Collectors.toList());
    }

运行结果：

这里我们创建了四个学生，经过filter的筛选，筛选出地址是浙江的学生集合。

2.5. findFirst

findFirst 可以查找出 Stream 流中的第一个元素，它返回的是一个 Optional 类型 。

/**
 * 查找第一个数据
 * 返回的是一个 Optional 对象
 */
@Test
public void findFirstTest(){
    List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Optional<Integer> firstNumber = numberList.stream()
            .findFirst();
    System.out.println(firstNumber.orElse(-1));
}
// 输出结果
// 1

findFirst 方法在查找到需要的数据之后就会返回不再遍历数据了，也因此 findFirst 方法可以对有无限数据的 Stream 流进行操作。

2.6. collect / toArray

Stream 流可以轻松的转换为其他结构，下面是几种常见的示例。

/**
 * Stream 转换为其他数据结构
 */
@Test
public void collectTest() {
    List<Integer> numberList = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5);
    // to array
    Integer[] toArray = numberList.stream()
            .toArray(Integer[]::new);
    // to List
    List<Integer> integerList = numberList.stream()
            .collect(Collectors.toList());
    // to set
    Set<Integer> integerSet = numberList.stream()
            .collect(Collectors.toSet());
    System.out.println(integerSet);
    // to string
    String toString = numberList.stream()
            .map(number -> String.valueOf(number))
            .collect(Collectors.joining()).toString();
    System.out.println(toString);
    // to string split by ,
    String toStringbJoin = numberList.stream()
            .map(number -> String.valueOf(number))
            .collect(Collectors.joining(",")).toString();
    System.out.println(toStringbJoin);
}
// 输出结果
// [1, 2, 3, 4, 5]
// 112233445
// 1,1,2,2,3,3,4,4,5

2.7. limit / skip

获取或者扔掉前 n 个元素

/**
 * 获取 / 扔掉前 n 个元素
 */
@Test
public void limitOrSkipTest() {
    // 生成自己的随机数流
    List<Integer> ageList = Arrays.asList(11, 22, 13, 14, 25, 26);
    ageList.stream()
            .limit(3)
            .forEach(age -> System.out.print(age+","));
    System.out.println();

    ageList.stream()
            .skip(3)
            .forEach(age -> System.out.print(age+","));
}
// 输出结果
// 11,22,13,
// 14,25,26,

2.8. Statistics

数学统计功能，求一组数组的最大值、最小值、个数、数据和、平均数等。

/**
 * 数学计算测试
 */
@Test
public void mathTest() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
    IntSummaryStatistics stats = list.stream().mapToInt(x -> x).summaryStatistics();
    System.out.println("最小值：" + stats.getMin());
    System.out.println("最大值：" + stats.getMax());
    System.out.println("个数：" + stats.getCount());
    System.out.println("和：" + stats.getSum());
    System.out.println("平均数：" + stats.getAverage());
}
// 输出结果
// 最小值：1
// 最大值：6
// 个数：6
// 和：21
// 平均数：3.5

2.9. groupingBy

分组聚合功能，和数据库的 Group by 的功能一致。

/**
 * groupingBy
 * 按年龄分组
 */
@Test
public void groupByTest() {
    List<Integer> ageList = Arrays.asList(11, 22, 13, 14, 25, 26);
    Map<String, List<Integer>> ageGrouyByMap = ageList.stream()            
        .collect(Collectors.groupingBy(age -> String.valueOf(age / 10)));
    ageGrouyByMap.forEach((k, v) -> {
        System.out.println("年龄" + k + "0多岁的有：" + v);
    });
}
// 输出结果
// 年龄10多岁的有：[11, 13, 14]
// 年龄20多岁的有：[22, 25, 26]

2.10. partitioningBy

/**
 * partitioningBy
 * 按某个条件分组
 * 给一组年龄，分出成年人和未成年人
 */
public void partitioningByTest() {
    List<Integer> ageList = Arrays.asList(11, 22, 13, 14, 25, 26);
    Map<Boolean, List<Integer>> ageMap = ageList.stream()
            .collect(Collectors.partitioningBy(age -> age > 18));
    System.out.println("未成年人：" + ageMap.get(false));
    System.out.println("成年人：" + ageMap.get(true));
}
// 输出结果
// 未成年人：[11, 13, 14]
// 成年人：[22, 25, 26]

2.11 distinct(去重)

 public static void main(String [] args) {

      testDistinct1();
    }

    /**
     * 集合去重（基本类型）
     */
    private static void testDistinct1() {
        //简单字符串的去重
        List<String> list = Arrays.asList("111","222","333","111","222");
        list.stream().distinct().forEach(System.out::println);
    }

运行结果：

public static void main(String [] args) {

      testDistinct2();
    }

    /**
     * 集合去重（引用对象）
     */
    private static void testDistinct2() {
        //引用对象的去重，引用对象要实现hashCode和equal方法，否则去重无效
        Student s1 = new Student(1L, "肖战", 15, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "杨紫", 17, "北京");
        Student s4 = new Student(4L, "李现", 17, "浙江");
        Student s5 = new Student(1L, "肖战", 15, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        students.add(s5);
        students.stream().distinct().forEach(System.out::println);
    }

运行结果：

可以看出，两个重复的“肖战”同学进行了去重，这不仅因为使用了distinct()方法，而且因为Student对象重写了equals和hashCode()方法，否则去重是无效的。

2.12 sorted(排序)

   public static void main(String [] args) {

        testSort1();
    }

    /**
     * 集合排序（默认排序）
     */
    private static void testSort1() {
        List<String> list = Arrays.asList("333","222","111");
        list.stream().sorted().forEach(System.out::println);
    }

运行结果：

  public static void main(String [] args) {

        testSort2();
    }

    /**
     * 集合排序（指定排序规则）
     */
    private static void testSort2() {
        Student s1 = new Student(1L, "肖战", 15, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "杨紫", 17, "北京");
        Student s4 = new Student(4L, "李现", 17, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        students.stream()
                .sorted((stu1,stu2) ->Long.compare(stu2.getId(), stu1.getId()))
                .sorted((stu1,stu2) -> Integer.compare(stu2.getAge(),stu1.getAge()))
                .forEach(System.out::println);
    }

运行结果：

上面指定排序规则，先按照学生的id进行降序排序，再按照年龄进行降序排序

2.13 limit（限制返回个数）

 public static void main(String [] args) {

        testLimit();
    }

    /**
     * 集合limit，返回前几个元素
     */
    private static void testLimit() {
        List<String> list = Arrays.asList("333","222","111");
        list.stream().limit(2).forEach(System.out::println);
    }

运行结果：

2.14 skip(删除元素)
public static void main(String [] args) {

    testSkip();
}

/**
 * 集合skip，删除前n个元素
 */
private static void testSkip() {
    List<String> list = Arrays.asList("333","222","111");
    list.stream().skip(2).forEach(System.out::println);
}

运行结果：

2.15 reduce(聚合)

public static void main(String [] args) {
    testReduce();
}
/**
 * 集合reduce,将集合中每个元素聚合成一条数据
 */
private static void testReduce() {
    List<String> list = Arrays.asList("欢","迎","你");
    String appendStr = list.stream().reduce("北京",(a,b) -> a+b);
    System.out.println(appendStr);
}

运行结果：

2.16 min(求最小值)

public static void main(String [] args) {
    testMin();
}

/**
 * 求集合中元素的最小值
 */
private static void testMin() {
    Student s1 = new Student(1L, "肖战", 14, "浙江");
    Student s2 = new Student(2L, "王一博", 15, "湖北");
    Student s3 = new Student(3L, "杨紫", 17, "北京");
    Student s4 = new Student(4L, "李现", 17, "浙江");
    List<Student> students = new ArrayList<>();
    students.add(s1);
    students.add(s2);
    students.add(s3);
    students.add(s4);
    Student minS = students.stream().min((stu1,stu2) ->Integer.compare(stu1.getAge(),stu2.getAge())).get();
    System.out.println(minS.toString());
}

运行结果：

上面是求所有学生中年龄最小的一个，max同理，求最大值。

2.17 anyMatch/allMatch/noneMatch（匹配）

public static void main(String [] args) {
    testMatch();
}

private static void testMatch() {
    Student s1 = new Student(1L, "肖战", 15, "浙江");
    Student s2 = new Student(2L, "王一博", 15, "湖北");
    Student s3 = new Student(3L, "杨紫", 17, "北京");
    Student s4 = new Student(4L, "李现", 17, "浙江");
    List<Student> students = new ArrayList<>();
    students.add(s1);
    students.add(s2);
    students.add(s3);
    students.add(s4);
    Boolean anyMatch = students.stream().anyMatch(s ->"湖北".equals(s.getAddress()));
    if (anyMatch) {
        System.out.println("有湖北人");
    }
    Boolean allMatch = students.stream().allMatch(s -> s.getAge()>=15);
    if (allMatch) {
        System.out.println("所有学生都满15周岁");
    }
    Boolean noneMatch = students.stream().noneMatch(s -> "杨洋".equals(s.getName()));
    if (noneMatch) {
        System.out.println("没有叫杨洋的同学");
    }
}

运行结果：

anyMatch：Stream 中任意一个元素符合传入的 predicate，返回 true
allMatch：Stream 中全部元素符合传入的 predicate，返回 true
noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

码客思
关注
java8中的流（Stream）
GuiBing_haonan的博客
02-24 520
流式编程爱 撸码就是快，流式编程好 代码传家宝 Stream API 概念： Stream 流处理，首先要澄清的是 java8 中的 Stream 与 I/O 流 InputStream 和 OutputStream 是完全不同的概念。 Stream 机制是针对集合迭代器的增强。流允许你用声明式的方式处理数据集合（通过查询语句来表达，而不是临时编写一个实现）。 1.流的基本流程 1.准备一个数据源（可以是集合，数组，I/O channel， 产生器generator 等） 2.一个中间操作链，形成一条流的流
Java-Stream流方法学习及总结
大仙
08-16 1914
前言 Stream是一个来自数据源的元素队列并支持聚合操作，其中具有以下特性： Stream只负责计算，不存储任何元素，元素是特定类型的对象，形成一个队列 数据源可以实集合、数组、I/O channel、generator等 聚合操作有类似SQL的：filter、map、match、sorted等操作 Stream流的执行类似于懒加载，用户使用时才执行相应操作 可消费性；Stream只能被消费一次，被消费后需要重新生成 本文总结了部分在日常开发中经常接触到的一些Stream流相关的方法，不足之处或有错误
Java stream判断列表是否包含某几个元素/重复元素
★【World Of Moshow 郑锴】★
10-07 2万+
背景 (需求经过修改过)判断一个profile是否包含PROFILE-IN-A和PROFILE-IN-B且都是Enable=1打勾的. 既然已经JDK8了,那就用lambda吧,如果是foreach可能比较难处理,用stream的filter则可以这样做. 核心代码可以这么写 int intCheck = profileServiceDtoList.stream().filter(e -> ...
创建list（asList和Stream.of）、合并list
dl674756321的博客
05-11 2041
1、asList的方式来创建list List<Integer> integers = asList(1, 2, 3); asList 返回的是一个由指定数组生成的固定大小的 List，所以它不支持插入和删除，也就是不支持动态扩容。 原因：它在创建list时，里面有一个也叫做ArrayList的内部类，这个内部类中有一个被声明为final的数组，所有传入的的元素都会保留到这个final数组中，所以其实它内部的这个ArrayList并不是java.util.ArrayList，而是java.ut
链表的插入
cyh19971997的博客
07-18 173
//单链表插入节点 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int elem; typedef struct Lnode { elem *data; struct Lnode *next; }Lnode,*list; //头插法节点; list creat(Lnode &amp;L) { Lnode *s; int...
一文学习Stream查找和匹配元素
weixin_54828627的博客
02-18 2072
在对数组或者集合类进行操作的时候，经常会遇到这样的需求，比如：是否包含某一个“匹配规则”的元素是否所有的元素都符合某一个“匹配规则”是否所有元素都不符合某一个“匹配规则”查找第一个符合“匹配规则”的元素查找任意一个符合“匹配规则”的元素这些需求如果用for循环去写的话，还是比较麻烦的，需要使用到for循环和break。下面使用Stream来完成这些操作。何用Stream API来实现“查找与匹配”Employee员工类：
Java8特性Stream流的使用（学完就会，项目源码，附带个人总结）
09-09
以下将详细介绍Stream流的使用，以及它在Java8中的重要性。 首先，Stream API是一种用于处理集合的新接口，它可以对集合进行各种操作，如过滤、映射、聚合等，而无需显式地遍历集合。这种处理方式称为“函数式编程...
Java如何使用Optional与Stream取代if判空逻辑（JDK8以上）
08-25
总结起来，Java 8的Optional和Stream API提供了一种更优雅的方式来处理可能为空的对象和数据流，使得代码更加简洁、可读性强，同时减少了由于null值引发的错误。通过学习和熟练掌握这些新特性，你可以提高代码质量，...
简单总结Java IO中stream流的使用方法
09-02
Stream流分为两种主要类型：数据流和打印流，它们都是Java入门学习的基础。 首先，我们来了解一下流的基本分类： 1. **方向分类**：Java IO中的流根据数据流动的方向分为输入流和输出流。输入流用于从数据源读取...
Java8新特性Stream流的概念和使用【详解】
weixin_65657777的博客
05-24 3979
🎉博客首页：痛而不言笑而不语的浅伤 📢欢迎关注🥳点赞 👍 收藏 ⭐留言 📝 欢迎讨论！ 🔮本文由痛而不言笑而不语的浅伤原创，CSDN首发！ 🌋系列专栏：《JavaSE系列详解》 🧿首发时间：2022年5月24日 ❤：热爱Java学习，期待一起交流！ 🙏🏻作者水平有限，如果发现错误，求告知，多谢！ 🥰有问题可以私信交流！！！ 目录 引言 Stream流的概念 为什么要使用Stream流？ Stream的两个基础的特征: Stream流的获取 通过Collection集合获取.
java8 stream：检查list集合对象中是否存在某个值
最新发布
weixin_50609559的博客
03-24 3281
java8 stream
Optional联合Stream使用——集合判空或取值
可乐多点冰的博客
12-17 7365
jdk8Optional联合Stream使用简单判空取值 原来判断 SspUnionPolicyDetailShowResp showResp = new SspUnionPolicyDetailShowResp(); InterestsCell interestsCell2 = new InterestsCell(); if (ObjectUtils.isNotEmpty(showResp) && ObjectUtils.
【HTTP】HTTP Stream 模式，服务端判断请求是否存在
原小明
05-23 2956
HTTP Stream 模式 客户端发起请求，服务端数据过大 或者 需要延时处理并且同步返回数据的场景 下面以 Flask 为例 1. 服务端 实现每隔 2s 返回一行数据 {task}-{time.now()}-{process} import time from datetime import datetime from flask import Flask, Response,request app = Flask(__name__) def compute(a): return f'{(
stream().filter过滤List对象
PhilsphyPrgram的博客
07-18 1918
查看下面的两种过滤方式，其实是一样的。 public static void main(String[] args) { List<Person> list = new ArrayList<>(); //定义三个用户对象 Person user1 = new Person(); user1.setId(1); user1.setName("林肯公园"); Person user2 = n
list stream：通过filter和findAny查找List中满足条件的某一个对象
技术人集结地
04-24 2万+
public static void main(String[] args) { List<User> userList = new ArrayList<>(); User one = new User(); one.setId(1); one.setAge(2); one.setName("h...
java8 新特性之stream用法
qq_34091758的博客
04-25 7060
//1. 得到集合中对象的某个属性的集合 list.stream().map(CheckRecord::getId).collect(Collectors.toList()); //2. 根据groupId分组, 得到map(key: groupId, value: 对应的list集合) Map<String, List<Stutent>> collectbyGroup...
stream 提取某字段_java8从list集合中取出某一属性的值的集合案例
热门推荐
易的博客
04-06 5万+
List orderNoList=list.stream().map(Order::getOrderNo).collect(Collectors.toList()); https://blog.csdn.net/weixin_39702400/article/details/111895006 我就废话不多说了，大家还是直接看代码吧~ List list = new ArrayList(); Order o1 = new Order("1","MCS-2019-1...
java8的stream流对list的常见操作
yangzhanghui的专栏
07-07 1万+
当我们对Stream 流中的数据操作完成之后，如果需要将流的结果进行保存，方便我们接下来对结果的继续操作，就得使用 Stream 流提供了的 collect() 方法，可以收集流中的数据到【集合】或者【数组】中。......
Java 使用Stream()过滤(filter)筛选List＜T＞列表数据并记录过滤的值日志方法代码
weixin_42098295的博客
06-27 1203
本文主要介绍Java中使用Stream()对List或ArrayList集合列表数据，进行过滤(filter)筛选数据并记录过滤的值日志方法代码。 原文地址：Java 使用Stream()过滤(filter)筛选List列表数据并记录过滤的值日志方法代码 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值