Stream

已于 2023-03-09 17:39:02 修改
阅读量617 收藏 1
点赞数 2
分类专栏： # stream流 文章标签： java
于 2021-07-13 14:11:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43296313/article/details/118698879
版权
本文详细介绍了Java Stream API的使用，包括创建流、遍历/匹配、筛选、聚合、映射、归约、收集等操作。通过实例展示了如何对集合进行高效处理，如查找、统计、分组和排序，并提供了员工薪资、名称等数据的处理示例。
摘要由CSDN通过智能技术生成

文章目录

Stream

在这里插入图片描述

1、Stream的创建

1、通过集合创建流

List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();

2、通过数组创建流

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

3、Stream的静态方法 of()、iterate()、generate()

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);
//输出结果：0 3 6 9

Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);
//输出结果：0.6796156909271994   0.1914314208854283    0.8116932592396652

2、Stream的使用

案例使用的员工类

@Data
public class Person {
	private String name;  // 姓名
	private int salary; // 薪资
	private int age; // 年龄
	private String sex; //性别
	private String area;  // 地区

	public Person(String name, int salary, String sex, String area) {
		this.name = name;
		this.salary = salary;
		this.sex = sex;
		this.area = area;
	}
}

    private List<Person> getData(){
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, "male", "New York"));
        personList.add(new Person("Jack", 7000, "male", "Washington"));
        personList.add(new Person("Lily", 7800, "female", "Washington"));
        personList.add(new Person("Anni", 8200, "female", "New York"));
        personList.add(new Person("Owen", 9500, "male", "New York"));
        personList.add(new Person("Alisa", 7900, "female", "New York"));
        return personList;
    }

2.1、遍历/匹配（foreach/find/match）

        List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

        // 遍历输出符合条件的元素   输出结果：7,8,9
        list.stream().filter(x -> x > 6).forEach(System.out::println);
        // 匹配第一个
        Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
        // 匹配任意（适用于并行流）
				// 只要在任何片段发现了第一个匹配元素就会结束整个运算
        Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
        // 是否包含符合特定条件的元素
        boolean anyMatch = list.stream().anyMatch(x -> x > 6);
        System.out.println("匹配第一个值：" + findFirst.get());//输出结果：7
        System.out.println("匹配任意一个值：" + findAny.get());//输出结果：7
        System.out.println("是否存在大于6的值：" + anyMatch);//输出结果：true

2.2 、 筛选（filter）

        // 筛选出集合中大于三小于8的元素
        Integer[] arr = new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        Arrays.stream(arr).filter(x -> x > 3 && x < 8).forEach(System.out::println);
        //输出结果 4,5,6,7

        //筛选员工中工资高于8000的人
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

        List<String> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());
        System.out.print("薪资高于8000美元的员工：" + fiterList);

2.3、聚合（max/min/count)

获取String集合中最长的元素

        List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");

        Optional<String> max = list.stream().max(Comparator.comparing(String::length));
        System.out.println("最长的字符串：" + max.get());
				//输出结果：最长的字符串：weoujgsd

获取Integer集合中的最大值

        List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);

        // 自然排序
        Optional<Integer> max = list.stream().max(Integer::compareTo);
        // 自定义排序（从大到小排序）
        Optional<Integer> max2 = list.stream().max((o1, o2) -> o2 - o1);
        System.out.println("自然排序的最大值：" + max.get());
        //输出结果：自然排序的最大值：11
        System.out.println("自定义排序的最大值：" + max2.get());
        //输出结果：自定义排序的最大值：4

获取员工薪资最高的人

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

        int salary = personList.stream().max(Comparator.comparingInt(Person::getSalary)).get().getSalary();
        System.out.println("员工薪资最大值：" + salary);
        //输出结果：员工薪资最大值：9500

计算Integer集合中大于6的元素的个数

        List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);

        long count = list.stream().filter(x -> x > 6).count();
        System.out.println("list中大于6的元素个数：" + count);
        //输出结果：list中大于6的元素个数：4

2.4 映射(map/flatMap)

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：

  • map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
  • flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

英文字符串数组的元素全部改为大写。整数数组每个元素+3

        String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
        List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());

        List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
        List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());

        System.out.println("每个元素大写：" + strList);
        //输出结果：每个元素大写：[ABCD, BCDD, DEFDE, FTR]
        System.out.println("每个元素+3：" + intListNew);
        //输出结果：每个元素+3：[4, 6, 8, 10, 12, 14]

将员工的薪资全部增加10000

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

        // 不改变原来员工集合的方式
        List<Person> personListNew = personList.stream().map(person -> {
            Person personNew = new Person(person.getName(), 0, 0, null, null);
            personNew.setSalary(person.getSalary() + 10000);
            return personNew;
        }).collect(Collectors.toList());
        System.out.println("一次改动前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());
        System.out.println("一次改动后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());

        // 改变原来员工集合的方式
        List<Person> personListNew2 = personList.stream().map(person -> {
            person.setSalary(person.getSalary() + 10000);
            return person;
        }).collect(Collectors.toList());
        System.out.println("二次改动前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());
        System.out.println("二次改动后：" + personListNew2.get(0).getName() + "-->" + personListNew.get(0).getSalary());

输出结果：

一次改动前：Tom–>8900
一次改动后：Tom–>18900
二次改动前：Tom–>18900
二次改动后：Tom–>18900

将两个字符数组合并成一个新的字符数组

        List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
        List<String> listNew = list.stream().flatMap(s -> {
            // 将每个元素转换成一个stream
            String[] split = s.split(",");
            Stream<String> s2 = Arrays.stream(split);
            return s2;
        }).collect(Collectors.toList());

        System.out.println("处理前的集合：" + list);
        //输出结果：处理前的集合：[m-k-l-a, 1-3-5]
        System.out.println("处理后的集合：" + listNew);
        输出结果：处理后的集合：[m, k, l, a, 1, 3, 5]

2.5、归约(reduce)

归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作

求Integer集合的元素之和、乘积和最大值

        List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
        // 求和方式1
        Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
        // 求和方式2
        Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
        // 求和方式3
        Integer sum3 = list.stream().reduce(0, Integer::sum);

        // 求乘积
        Optional<Integer> product = list.stream().reduce((x, y) -> x * y);

        // 求最大值方式1
        Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
        // 求最大值写法2
        Integer max2 = list.stream().reduce(1, Integer::max);

        System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
        //输出结果：list求和：29,29,29
        System.out.println("list求积：" + product.get());
        //输出结果：list求积：2112
        System.out.println("list求最大值：" + max.get() + "," + max2);
        //输出结果：list求最大值：11,11

求所有员工的工资之和和最高工资

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

        // 求工资之和方式1：
        Optional<Integer> sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum);
        // 求工资之和方式2：
        Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum + p.getSalary(), Integer::sum);

        // 求最高工资方式：
        Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
                Integer::max);

        System.out.println("工资之和：" + sumSalary.get() + "," + sumSalary2 );
        //输出结果：工资之和：49300,49300
        System.out.println("最高工资：" + maxSalary);
        //输出结果：最高工资：9500

2.6、收集(collect)

2.6.1 归集(toList/toSet/toMap)
        List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
        List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
        Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));

        Map<String, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
                .collect(Collectors.toMap(Person::getName, p -> p));
        Map<String, Integer> map1 = personList.stream().filter(p -> p.getSalary() > 8000)
                .collect(Collectors.toMap(Person::getName, Person::getAge));
        System.out.println("toList:" + listNew);
        //输出结果：toList：[6, 4, 6, 6, 20]
        System.out.println("toSet:" + set);
        //输出结果：toSet：[4, 20, 6]
        System.out.println("toMap:" + map);
        //输出结果：toMap:{Tom=Person(name=Tom, salary=8900, age=23, sex=male, area=New York), Anni=Person(name=Anni, salary=8200, age=24, sex=female, area=New York)}
        System.out.println("toMap:" + map1);
        输出结果：toMap:{Tom=23, Anni=24}
2.6.2 统计(count/averaging)
  • 计数：count
  • 平均值：averagingInt、averagingLong、averagingDouble
  • 最值：maxBy、minBy
  • 求和：summingInt、summingLong、summingDouble
  • 统计以上所有：summarizingInt、summarizingLong、summarizingDouble

统计平均工资、工资总额、最高工资

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));


        // 求平均工资
        Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
        // 求最高工资
        Optional<Integer> max = personList.stream().map(Person::getSalary).max(Integer::compare);
        // 求工资之和
        int sum = personList.stream().mapToInt(Person::getSalary).sum();
        // 一次性统计所有信息
        DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

        System.out.println("员工平均工资：" + average);
        //输出结果：员工平均工资：7900.0
        System.out.println("员工最高工资：" + sum);
        //输出结果：员工最高工资：23700
        System.out.println("员工工资总和：" + sum);
        //输出结果：员工工资总和：23700
        System.out.println("员工工资所有统计：" + collect);
        //输出结果：员工工资所有统计：DoubleSummaryStatistics{count=3, sum=23700.000000, min=7000.000000, average=7900.000000, max=8900.000000}
2.6.3 分组(partitioningBy/groupingBy)
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, "male", "New York"));
        personList.add(new Person("Jack", 7000, "male", "Washington"));
        personList.add(new Person("Lily", 7800, "female", "Washington"));
        personList.add(new Person("Anni", 8200, "female", "New York"));
        personList.add(new Person("Owen", 9500, "male", "New York"));
        personList.add(new Person("Alisa", 7900,"female", "New York"));

        // 将员工按薪资是否高于8000分组
        Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
        // 将员工按性别分组
        Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        // 将员工先按性别分组，再按地区分组
        Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        System.out.println("员工按薪资是否大于8000分组情况：" + part);
        System.out.println("员工按性别分组情况：" + group);
        System.out.println("员工按性别、地区：" + group2);

输出结果

员工按薪资是否大于8000分组情况：{false=[Person(name=Jack, salary=7000, age=0, sex=male, area=Washington), Person(name=Lily, salary=7800, age=0, sex=female, area=Washington), Person(name=Alisa, salary=7900, age=0, sex=female, area=New York)], true=[Person(name=Tom, salary=8900, age=0, sex=male, area=New York), Person(name=Anni, salary=8200, age=0, sex=female, area=New York), Person(name=Owen, salary=9500, age=0, sex=male, area=New York)]}
员工按性别分组情况：{female=[Person(name=Lily, salary=7800, age=0, sex=female, area=Washington), Person(name=Anni, salary=8200, age=0, sex=female, area=New York), Person(name=Alisa, salary=7900, age=0, sex=female, area=New York)], male=[Person(name=Tom, salary=8900, age=0, sex=male, area=New York), Person(name=Jack, salary=7000, age=0, sex=male, area=Washington), Person(name=Owen, salary=9500, age=0, sex=male, area=New York)]}
员工按性别、地区：{female={New York=[Person(name=Anni, salary=8200, age=0, sex=female, area=New York), Person(name=Alisa, salary=7900, age=0, sex=female, area=New York)], Washington=[Person(name=Lily, salary=7800, age=0, sex=female, area=Washington)]}, male={New York=[Person(name=Tom, salary=8900, age=0, sex=male, area=New York), Person(name=Owen, salary=9500, age=0, sex=male, area=New York)], Washington=[Person(name=Jack, salary=7000, age=0, sex=male, area=Washington)]}}
2.6.4 接合(joining)
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

        String names = personList.stream().map(Person::getName).collect(Collectors.joining(","));
        System.out.println("所有员工的姓名：" + names);
        //输出结果：所有员工的姓名：Tom,Jack,Lily

        List<String> list = Arrays.asList("A", "B", "C");
        String string = list.stream().collect(Collectors.joining("-"));
        System.out.println("拼接后的字符串：" + string);
        //输出结果：拼接后的字符串：A-B-C
2.6.5 归约(reducing)

Collectors类提供的reducing方法，相比于stream本身的reduce方法，增加了对自定义归约的支持

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

        // 每个员工减去起征点后的薪资之和（这个例子并不严谨，但一时没想到好的例子）
        Integer sum = personList.stream().map(Person::getSalary).reduce(0, (i, j) -> (i + j - 5000));
        System.out.println("员工扣税薪资总和：" + sum);
        //输出结果：员工扣税薪资总和：8700
        // stream的reduce
        Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
        System.out.println("员工薪资总和：" + sum2.get());
        //输出结果：员工薪资总和：23700

2.7、排序(sorted)

  • sorted()：自然排序，流中元素需实现Comparable接口
  • sorted(Comparator com)：Comparator排序器自定义排序

将员工按工资由高到低（工资一样则按年龄由大到小）排序

        List<Person> personList = new ArrayList<>();

        personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
        personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
        personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 8800, 26, "male", "New York"));
        personList.add(new Person("Alisa", 9000, 26, "female", "New York"));

        // 按工资升序排序（自然排序）
        List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
                .collect(Collectors.toList());
        // 按工资倒序排序
        List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
                .map(Person::getName).collect(Collectors.toList());
        // 先按工资再按年龄升序排序
        List<String> newList3 = personList.stream()
                .sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName)
                .collect(Collectors.toList());
        // 先按工资再按年龄自定义排序（降序）
        List<String> newList4 = personList.stream().sorted((p1, p2) -> {
            if (p1.getSalary() == p2.getSalary()) {
                return p2.getAge() - p1.getAge();
            } else {
                return p2.getSalary() - p1.getSalary();
            }
        }).map(Person::getName).collect(Collectors.toList());

        System.out.println("按工资升序排序：" + newList);
        //输出结果：按工资升序排序：[Lily, Tom, Sherry, Jack, Alisa]
        System.out.println("按工资降序排序：" + newList2);
        //输出结果：按工资降序排序：[Sherry, Jack, Alisa, Tom, Lily]
        System.out.println("先按工资再按年龄升序排序：" + newList3);
        //输出结果：先按工资再按年龄升序排序：[Lily, Tom, Sherry, Jack, Alisa]
        System.out.println("先按工资再按年龄自定义降序排序：" + newList4);
        //输出结果：先按工资再按年龄自定义降序排序：[Alisa, Jack, Sherry, Tom, Lily]

2.8、合并/去重/跳过

        String[] arr1 = { "a", "b", "c", "d" };
        String[] arr2 = { "d", "e", "f", "g" };

        Stream<String> stream1 = Stream.of(arr1);
        Stream<String> stream2 = Stream.of(arr2);
        // concat:合并两个流 distinct：去重
        List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
        // limit：限制从流中获得前n个数据
        List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
        // skip：跳过前n个数据
        List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());

        System.out.println("流合并：" + newList);
        //输出结果：流合并：[a, b, c, d, e, f, g]
        System.out.println("limit：" + collect);
        //输出结果：limit：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
        System.out.println("skip：" + collect2);
        //输出结果：skip：[3, 5, 7, 9, 11]
yololee_
关注
专栏目录
stream流排序
qq_36763236的博客
12-21 2万+
List 倒序排列 List<Double> salesData = new ArrayList<>(); Collections.reverse(salesData); java8 stream多字段排序 List<类> rankList = new ArrayList<>(); 代表某个集合 //返回 对象集合以类属性一升序排序 rankList.stream().sorted(Comparator.comparing(类::属性一));
Stream流sorted方法,reversed注意事项
weixin_43999284的博客
12-16 6343
stream流多个条件倒序排序时注意的点
Java8新特性-Stream
ThinkWon的博客
02-12 8819
文章目录简介Stream 的特性创建Stream通过集合创建流通过数组创建流通过Stream.of方法创建流创建规律的无限流创建无限流创建空流Stream操作分类中间操作无状态filtermapflapMap有状态distinctsortedsortedreversedthenComparinglimitskipconcat终结操作非短路操作forEachreducecollecttoList，toSet，toSetgroupingBypartitioningBymax、mincountsummarySta
Java8之stream
KHOST的博客
12-15 486
本文讲述.stream()的内容，需要一些Lambda表达式的基础，之前也推送过关于Lambda表达式和Stream的相关内容，就看哪盘菜味道更好！ 一、初识stream 先来一个总纲： 东西就是这么多啦，stream是java8中加入的一个非常实用的功能，最初看时以为是io中的流（其实一点关系都没有），让我们先来看一个小例子感受一下： @Before public void ini...
java stream使用指南-------sorted使用及进阶
ql_7256的博客
05-02 2万+
文章目录引入数据准备1. 依赖2. 相关类初体验基础用法1. 逆序几种写法2. 多级排序3. null值处理进阶1. 本质2. 拓展 引入 用了一段时间的jdk8的新特性，lambda表达式、方法引用、stream流，用起来是真的顺手啊，最近碰到了一个排序的问题，引发了一些思考，然后就写了这篇博客，归纳总结sorted的用法，在做笔记的同时也让自己有更深的理解。 数据准备 1. 依赖 我喜欢用google的集合工具类，让我构造测试数据更简便。然后也用lombok，依赖： <!--goo
java使用stream对日期排序
11-17
在Java编程中，Stream API是Java 8引入的一个强大特性，它允许我们以声明性方式处理数据集合。本文将深入探讨如何使用Stream API对日期进行排序。日期排序在数据分析、日志处理、报表生成等场景中非常常见。下面我们...
Linux内存性能测试工具stream
07-27
"Linux内存性能测试工具stream"是一个专门用于评估计算机内存（RAM）性能的工具。本文将深入探讨STREAM的作用、工作原理以及如何在Linux环境中使用它。 STREAM，全称是“Simple Triad Memory Benchmark”，是由John...
Elecard-StreamEye-Tools.zip_Elecard_Elecard StreamEye _elecard工具
07-14
《Elecard StreamEye工具：专业视频压缩分析的得力助手》 Elecard StreamEye Tools是一款专为视频压缩领域设计的专业工具集，它以其强大的功能和深入的分析能力，深受业界专业人士的喜爱。这款软件旨在帮助用户对...
streamsets-帮助手册-.pdf
06-09
StreamSets 帮助手册 StreamSets 是一个数据integration平台，用于处理和处理大规模数据流。以下是根据 StreamSets 帮助手册生成的知识点： Pipeline 概念和设计 Pipeline 是 StreamSets 的核心概念，用于描述...
Elecard StreamEye Tool(3.0) StreamEye(4.0) HEVC-Analyzer
05-02
StreamEye工具和HEVC-Analyzer是两款在视频编码分析领域非常重要的软件，尤其对于IT专业人员和视频编码工程师来说，它们是理解和优化视频流的重要工具。这两款软件由Elecard公司开发，专注于处理H.264和H.265（也...
Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】
最新发布
Tony666688888的博客
04-07 6297
java8 Stream中sorted排序
项目中的基础知识
早上真起不来的博客
07-15 498
yml中mytesthttps使用${添加链接描述添加链接描述​httpshttpshttpshttpshttps。
stream流排序（升序降序）
li836779537的博客
12-26 4041
【代码】stream流排序（升序降序）
Java8 stream
qianhuan_的博客
11-30 1829
排序（倒序，正序去掉reversed()，根据Reporting实体的isDeadLine字段倒序） List<Reporting> collect1 = integerListEntry.getValue().stream().sorted(Comparator.comparing(Reporting::getIsDeadLine).reversed()).collect(Collectors.toList()); List 转 map 相同key,value 合为一个List（..
Java Stream流式处理
chy1984的博客
04-15 5264
findFirst()、findAny() 返回 Optional，但选取的元素是null时，这2个方法会直接抛出NPE，后续也就没必要用 Optional 的 orElse()、orElseGet() 来设置为 null 时的默认值。stream 流，是jdk8新增的一种集合处理方式，可以将集合转换为流，进而对集合中的元素进行排序、过滤、聚合等⼀系列的操作。相比于map()，mapToXxx() 还提供了该种类型的流的特有方法，比如数值型求和、平均数、最值。将流中的元素映射为对应的流（列表）
Java8中Stream的常用方法
阳阳的博客
06-10 4661
一、前言 这篇文章简单总结一下Lambda中的常用方法 对Lambda不熟悉的同学，可以参考这篇进行入门对Lambda的理解，Lambda真是越用越爽 如果刚刚入门Lambda，但对Consumer、Supplier、Predicate与Function不怎么熟悉的同学，可以参考这篇文章快速理解Consumer、Supplier、Predicate与Function 如果已经对Lambda很熟悉的同学，但对其执行原理不太懂的同学，可以参考我的这篇文章Lambda执行原理 二、排序 需求，按照学生
Java中的排序问题（Java8新特性 stream流、stream多字段排序）
ProBaiXiaodi的博客
11-19 6990
Java中的排序问题（Java8新特性 stream流、stream多字段排序）： 学习内容： 一、什么是流 二、stream特性 一、概要 Java 8 API添加了一个新的抽象成为流Stream，它以一种声明的方式处理数据，最后由最终操做获得前面处理的结果。java Stream专一于集合对象的操做，将要处理的元素集合看做一种流， 流在管道中传输， 而且能够在管道的节点上进行处理， 好比筛选， 排序，聚合等。程序员 Stream在处理大批量数据操做中更加高效。算法 Strea
【使用stream流各种排序以及常用的一些方法】
weixin_43898002的博客
07-27 1万+
stream流的排序使用及其他的一些常用方法
JDK 8 之 Stream sorted() 示例
热门推荐
舒哥的blog
03-19 15万+
原文链接：http://www.concretepage.com/java/jdk-8/java-8-stream-sorted-example 国外对Java8一系列总结的不错， 翻译过来给大家共享 这篇文章将会讲解Java 8 Stream sorted()示例， 我们能够以自然序或着用Comparator 接口定义的排序规则来排序一个流。Comparator 能用用lambada表达式来初
stream
05-27
stream()是Java 8中新增的一个方法，它可以将集合转化为一个流（Stream）。流是一种数据处理的方式，它可以通过一系列的中间操作来对数据进行处理，最终生成想要的结果。使用流式处理可以简化代码，提高代码的可读性...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值