JDK8新特性(八)之Stream流的map()、sorted()、distinct()、match()方法

已于 2024-08-10 13:25:02 修改
阅读量4.9k 收藏 16
点赞数 6
分类专栏： 杂文 文章标签： java
于 2021-12-08 23:07:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y_bccl27/article/details/121801551
版权

一、Stream流的map()方法

1.1 map方法的介绍

如果需要将流中的元素映射到另一个流中，可以使用map方法。方法声明：

<R> Stream<R> map(Function<? super T,? extends R> mapper);

该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一个R类型的流。

import java.util.stream.Stream;

public class Demo {

    public static void main(String[] args) {
        Stream<String> original = Stream.of("11","22","33");

        //Map可以将一种类型的流转换成另一种类型的流
        //将Stream流中的字符串转成Integer
        //Stream<Integer> stream = original.map((String s)->{
        //    return Integer.parseInt(s);
        //});
        //original.map(s->Integer.parseInt(s)).forEach(System.out::println);
        //map方法的参数通过方法引用，将字符串类型转换成为int类型（并自动装箱为Integer类对象）
        original.map(Integer::parseInt).forEach(System.out::println);
    }
}

执行上述代码，其输出结果为：

11
22
33

1.2 将List<Object>转换为自定义的List<Map>

import lombok.Data;

@Data
public class Person {

    private String name;
    private int sex;
    private String address;
    private String phoneNumber;
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Demo {

    private static List<Person> buildData(int number){
        List<Person> list =new ArrayList<>();
        for(int i=0;i<number;i++){
            Person person=new Person();
            person.setName("张三"+i);
            person.setSex(1);
            person.setPhoneNumber("1880521321"+i);
            person.setAddress("北京天通苑"+i);
            list.add(person);
        }
        return list;
    }

    public static void main(String[] args){
        List<Person> personList=buildData(3);
        List<Map> collect = personList.stream().map(x -> {
            Map map = new HashMap();
            map.put("name", x.getName());
            map.put("sex", x.getSex());
            map.put("address", x.getAddress());
            return map;
        }).collect(Collectors.toList());
        System.out.println(collect);
    }
}

执行上述代码，其输出结果为： 

[{address=北京天通苑0, sex=1, name=张三0}, {address=北京天通苑1, sex=1, name=张三1}, {address=北京天通苑2, sex=1, name=张三2}]

1.3 将List<Object>转换为对象中的某个字段的集合

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.List;

@NoArgsConstructor
@Data
@AllArgsConstructor
public class Student {

    private int classId;
    private String name;
    private int score;

    public static List<Student> buildData(){
        List<Student> studentList = new ArrayList<>();
        Student student1 = new Student(1,"张三",80);
        Student student2 = new Student(1,"李四",59);
        Student student3 = new Student(2,"王五",90);
        studentList.add(student1);
        studentList.add(student3);
        studentList.add(student2);
        return studentList;
    }
}
import java.util.List;
import java.util.stream.Collectors;

public class Demo {

    public static void main(String[] args) {
        List<Student> studentList = Student.buildData();
        List<String> names = studentList.stream().map(Student::getName).collect(Collectors.toList());
        System.out.println(names);
    }
}

执行上述代码，其输出结果为：  

[张三, 王五, 李四]

二、Stream流的flatMap()方法

flatMap()方法的作用是将嵌套的列表集合进行平铺，最后使用collect(Collectors.toList())收集结果为一个新的List。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Demo {

    public static void main(String[] args) throws Exception{
        List<List<String>> nestedList = Arrays.asList(
                Arrays.asList("a", "b"),
                Arrays.asList("c", "d"),
                Arrays.asList("e", "f")
        );
        System.out.println("嵌套列表：" + nestedList);

        List<String> flatList = nestedList.stream().flatMap(List::stream).collect(Collectors.toList());
        System.out.println("打平列表：" + flatList);
    }
}

执行上述代码，其输出结果为：   

嵌套列表：[[a, b], [c, d], [e, f]]
打平列表：[a, b, c, d, e, f]

三、Stream流的sorted()方法 

3.1 sorted()方法的介绍

如果需要将数据排序，可以使用sorted方法。方法声明：

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);
import java.util.stream.Stream;

public class Demo {

    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(33,22,11,55);
        // sorted()：根据元素的自然顺序排序
        //stream.sorted().forEach(System.out::println);
        // sorted(Comparator<? super T> comparator)：根据比较指定的规则排序
        stream.sorted((Integer i1,Integer i2)->{
            return i2-i1;
        }).forEach(System.out::println);
    }
}

执行上述代码，其输出结果为：

55
33
22
11

上述stream.sorted()方法还可以进一步简化：

stream.sorted((i1,i2)-> i2-i1).forEach(System.out::println);

sorted方法除了可以根据元素的自然顺序排序，也可以指定比较器排序

3.2 指定比较器进行排序

3.2.1 升序排序

//对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));

例如下面这个示例就是以User类的id属性进行升序排序：

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;

@Data
@AllArgsConstructor
public class User {

    private int id;
    private String name;

    public static List<User> buildData(){
        List<User> userList = new ArrayList<>();
        User user1 = new User(1,"张三");
        User user2 = new User(2,"李四");
        User user3 = new User(3,"王五");
        userList.add(user2);
        userList.add(user1);
        userList.add(user3);
        return userList;
    }
}
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class SortedDemo {

    public static void main(String[] args){
        List<User> userList = User.buildData();
        System.out.println("排序前：");
        userList.forEach(System.out::println);

        System.out.println("排序后：");
        userList = userList.stream().sorted(Comparator.comparing(User::getId)).collect(Collectors.toList());
        userList.forEach(System.out::println);
    }
}

执行上述代码，其输出结果为：

排序前：
User(id=2, name=李四)
User(id=1, name=张三)
User(id=3, name=王五)
排序后：
User(id=1, name=张三)
User(id=2, name=李四)
User(id=3, name=王五)

四、Stream流的distinct()方法

如果需要去除重复数据，可以使用distinct方法。方法声明：

Stream<T> distinct();
import java.util.stream.Stream;

public class Demo {

    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(22,33,22,11,33);
        stream.distinct().forEach(System.out::println);
        Stream<String> stream1 = Stream.of("aa","bb","aa","bb","cc");
        stream1.distinct().forEach(System.out::println);
    }
}

执行上述代码，其输出结果为：

22
33
11
aa
bb
cc

distinct对自定义对象去除重复，首先需要对类的equals()和hscode()进行重写

public class Person {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if(this==o) {
            return true;
        }
        if(o==null || getClass()!=o.getClass()) {
            return false;
        }
        Person person =(Person)o;
        if(age!=person.age) {
            return false;
        }
        return name!=null?name.equals(person.name):person.name ==null;
    }

    @Override
    public int hashCode(){
        int result =name!=null?name.hashCode():0;
        result=31*result+age;
        return result;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name=" + name +
                ", age=" + age +
                '}';
    }
}
public static void main(String[] args) {
    Stream<Person> stream = Stream.of(
            new Person("貂蝉",18),
            new Person("西施",18),
            new Person("西施",18),
            new Person("王昭君",18)
    );
    stream.distinct().forEach(System.out::println);
}

执行上述代码，其输出结果为：

Person{name=貂蝉, age=18}
Person{name=西施, age=18}
Person{name=王昭君, age=18}

五、Stream流的match()方法

如果需要判断数据是否匹配指定的条件，可以使用Match相关方法。方法声明：

boolean allMatch(Predicate<? super T> predicate);
boolean anyMatch(Predicate<? super T> predicate);
boolean noneMatch(Predicate<? super T> predicate);
public static void main(String[] args) {
    Stream<Integer> stream = Stream.of(7,8,6,4);
    //boolean b=stream.allMatch(i->i>0); //allMatch：匹配所有元素，所有元素都需要满足条件
    boolean b =stream.noneMatch(i-> i<5);//noneMatch：匹配所有元素，所有元素都不满足条件则返回true
    System.out.println(b);
}

执行上述代码，其输出结果为：

false

5.1 anyMatch

anyMatch：只要有一个元素满足条件，就返回true，否则返回false。 

import java.util.ArrayList;
import java.util.List;

public class Demo {

    private static List<String> buildData(){
        List<String> list =new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        return list;
    }

    public static void main(String[] args){
        // list列表中只要有一个为“张三”，那么就返回True，否则的话返回False
        List<String> list = buildData();
        boolean flag= list.stream().anyMatch((String name) -> "张三".equals(name));
        System.out.println(flag);
    }
}

执行上述代码，其输出结果为：

true
y_bccl27
关注
专栏目录
JDK8新特性(十)之Stream流的map和reduce组合使用、mapToInt()、concat()方法
北辰
12-12 2155
1.Stream流的map和reduce组合使用 假设当前存在Person类，下述两个Person类的需求都是借助Stream流的map()和reduce()方法 import lombok.AllArgsConstructor; import lombok.Data; @Data @AllArgsConstructor public class Person { private String name; private int age; } 第一个需求：当前需要求出所有年龄的..
JDK8新特性——Stream流
m0_47360542的博客
09-13 275
JDK8新特性——Stream流
Java 8 Stream Api 中的 map和 flatMap 操作方法
08-25
Java 8提供了非常好用的 Stream API ,可以很方便的操作集合。今天通过这篇文章给大家分享Java 8 Stream Api 中的 map和 flatMap 操作方法,需要的朋友可以参考下
【Java学习】Map集合&Stream流
最新发布
weixin_69134024的博客
09-03 1133
Map集合称为双列集合，一次需要存一对数据做为一个元素，格式：{key1=value1 , key2=value2 , key3=value3 , ...}Map集合的每个元素分为两部分:key和value，key称为键，value称为值，整体叫键值对，因此Map也叫“键值对集合”Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值在需要存储一一对应的数据时，就可以考虑使用Map集合来做，例如购物网站中，商品编号和商品数量一一对应Map集合体系。
Stream流中map方法
weixin_45531950的博客
08-15 7万+
Stream流中map方法 使用Stream流时发现其中的map方法使用有一些不太容易理解的地方，分析一下具体的流程，以一个小案例详细探讨Stream中map的使用。 案例涉及： 1、Stream中of方法传入可变参数 2、Stream中map元素类型转化方法 3、Function匿名接口，people匿名对象的使用 4、String中split切割方法 5、Lambda表达式 匿名对象也可以使用...
Java中学习Stream流的map方法
李长渊的博客
03-24 1万+
Java中学习Stream流的map方法
Stream流中Map方法的使用
qq_44113347的博客
06-25 4019
map函数的作用就是针对管道流中的每一个数据元素进行转换操作。主要有三种用法。
stream().map()方法详解
热门推荐
qq_41135605的博客
11-04 20万+
使用Stream流时发现其中的map方法使用不好容易理解，以一个小案例详细探讨Stream中map的使用。 案例涉及知识点： 1、Stream中of方法传入可变参数 2、Stream中map元素类型转化方法 3、Function匿名接口，自定义类匿名对象的使用 4、Lambda表达式 为了便于理解，首先借鉴其他博客中的说法， stream()优点 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。 为函数式编程而生。对strea
JDK8新特性——Stream.pdf
08-06
JDK8是Java语言发展史上的重要里程碑，它引入了大量新特性，其中最引人注目的就是Stream API。Stream API为集合提供了强大的处理能力，可以让我们以声明式的方式处理集合中的数据，其操作主要分为三大类：中间操作...
jdk8新特性stream流式计算常用方法
pipizhen_的博客
04-16 1129
jdk8新特性stream流式计算 Stream的特点： （1）不存储元素； （2）不改变源数据； （3）具有延迟执行，类似懒加载。 特此记录Stream的学习案例： 先设计一个类： package com.pipi.test; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import lombok.experimental.Accessors; import org.jun
jdk8新特性（Stream流和日期）
qq_32424581的博客
10-18 495
二、java8日期的使用，涉及getYear、getMonthValue、getHour、plusDays、minusDays、minusMonths、plusMonths、Period.between、ChronoUnit.MONTHS.between、Instant.now()、Instant.plus、Duration.ofSeconds(10)、Duration.between、isAfter、Clock、ZoneId等类和方法。
【jdk8新特性】Stream流
m0_71229547的博客
06-04 1181
对集合进行处理操作的方法stream流的特性如下： 结果 结果可以看出相同情况下，Stream流对集合的处理更加的简单并且便于理解，Stream流通常与lambda表达式配合使用。例子 几个注意点：例子 注意点补充终结方法**作用：**遍历集合元素例子 可以看出利用lambda表达式可以把遍历操作大幅度简化**作用：**返回集合元素个数例子 filter方法： **作用：**过滤集合中不符合要求的元素例子 limit方法： **作用：**获取集合前n个元素例子 skip方法： *...
Stream流中的Map方法
qq_44113347的博客
03-27 7092
中的每个元素应用一个函数，并将结果存储在一个新的。方法将每个字符串元素转换为大写字母，最后通过。在Java 8及以上的版本中，是一个函数，接受一个元素类型为。对象，其中每个元素都是通过应用。方法创建了一个包含字符串元素的。以下是一个示例，展示如何使用。在上述示例中，我们首先使用。方法遍历输出转换后的结果。的参数，并返回一个类型为。
Stream流学习（二）map方法
weixin_44141172的博客
08-11 5805
Stream流 map方法
JDK8-Stream（Map）
baiofchao
09-07 1204
JDK8-Stream-Map
jdk8的特性stream().map()
曹学成的博客
01-13 978
private void loadCategoryAndBrandName(List<Spu> list) { for (Spu spu:list) { //处理分类 List<String> names = categoryService.queryByIds(Arrays.asList(spu.ge...
JDK 8 新特性 Stream map 相关
crazy_tong的博客
05-05 446
stream map 练习 和 clojure 里面的 map 理解 是一样的,可以分别获取流中的每一个元素,然后在对其做一些操作 map 基础练习 1. 遍历字符串集合然后转换成大写字母 public static void main(String[] args) { //之前的方式 List<String> names = Arrays.asList("crazy", "...
Stream流sorted的用法
06-02
Stream流中的sorted方法可以用于对流中的元素进行排序。它有两种用法： 1. sorted()：按照自然排序进行排序，如果流中的元素实现了Comparable接口，则使用该接口中的compareTo方法进行排序；否则会抛出ClassCastException异常。 2. sorted(Comparator<T> comparator)：按照指定的比较器进行排序。 例如，假设有一个List<String>，需要按照字符串长度进行排序，可以使用以下代码： ``` List<String> list = Arrays.asList("apple", "banana", "orange", "grape"); List<String> sortedList = list.stream() .sorted((s1, s2) -> s1.length() - s2.length()) .collect(Collectors.toList()); ``` 这里的sorted方法使用了lambda表达式来指定比较器，按照字符串长度进行排序。最终得到的结果为["grape", "apple", "banana", "orange"]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值