二、流中间操作

王大全

已于 2023-08-12 20:36:14 修改

阅读量411

点赞数

分类专栏： # Java8 流文章标签： java 数据结构开发语言

于 2023-04-24 23:11:02 首次发布

本文链接：https://blog.csdn.net/qq_36599530/article/details/130354396

版权

Java8 流专栏收录该内容

3 篇文章 0 订阅

订阅专栏

4.中间操作

流方法	含义
filter	用于通过设置的条件过滤出元素
distinct	返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流。
limit	会返回一个不超过给定长度的流。
skip	返回一个扔掉了前n个元素的流。
map	接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）。
flatMap	使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。
sorted	返回排序后的流

4.1筛选（filter）

/案例一：筛选出Integer集合中大于6的元素，并打印出来。public static void main(String[] args) {
    
    List<Integer> list = Arrays.asList(0, 6, 3, 5, 1, 2, 9, 7, 8);
    Stream<Integer> stream = list.stream();
    stream.filter(x -> x > 6).forEach(System.out::println);
}
//结果
9
7
8
  
//案例二：筛选出Person集合中年龄大于19员工姓名的元素，并打印出来。public static void main(String[] args) {

    List<Person> personList = new ArrayList<Person>();
    personList.add(new Person(1, "zhangsan", 18, "shanghai"));
    personList.add(new Person(2, "lisi", 19, "beijing"));
    personList.add(new Person(3, "wanger", 20, "guangdong"));
    personList.add(new Person(4, "mazi", 21, "jiangxi"));
    personList.add(new Person(5, "laoer", 22, "zhejiang"));

    List<String> filterList = personList.stream().filter(x -> x.getAge() > 19).map(Person::getName)
        .collect(Collectors.toList());
    System.out.print("年龄大于19员工姓名：" + filterList);
}

//结果
年龄大于19员工姓名：[wanger, mazi, laoer]

4.2去重(distinct)
通过流中元素的 hashCode() 和 equals() 去除重复元素

//去除重复元素
public static void main(String[] args) {

    List<Integer> list = Arrays.asList(0, 6, 3, 5, 1, 2, 9, 7, 8);
    Stream<Integer> stream = list.stream();
    stream.filter(x -> x > 6).distinct().forEach(System.out::println);
}

//结果
9
7
8

4.3获取元素skip(n)
跳过n元素，配合limit(n)可实现分页

//跳过前两个元素
public static void main(String[] args) {

    List<Integer> list = Arrays.asList(0, 6, 3, 5, 1, 2, 9, 7, 8);
    Stream<Integer> stream = list.stream();
    stream.filter(x -> x > 6).skip(2).forEach(System.out::println);
}

//结果
8

4.4跳过元素limit(n)
获取n个元素

//获取第几个元素
public static void main(String[] args) {

    List<Integer> list = Arrays.asList(0, 6, 3, 5, 1, 2, 9, 7, 8);
    Stream<Integer> stream = list.stream();
    stream.filter(x -> x > 6).limit(2).forEach(System.out::println);
}

//结果
9
7

4.5映射(map/flatMap)
可以将一个流的元素按照一定的映射规则映射到另一个流中

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

其实map方法就相当于Collaction的add方法，如果add的是个集合得话就会变成二维数组，而flatMap 的话就相当于Collaction的addAll方法，参数如果是集合得话，只是将2个集合合并，而不是变成二维数组。

在这里插入图片描述

//案列一:整个数组的数组元素+10
public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3, 4);
    List<Integer> collect = list.stream().map(x -> x + 10).collect(Collectors.toList());
    System.out.println(collect);
}

//结果
[11, 12, 13, 14]

//案列二:将两个字符数组合并成一个新的字符数组。public static void main(String[] args) {

    List<String> list = Arrays.asList("a,b,c,d", "e,f,g,h");
    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);
    System.out.println("转换后后的数据：" + listNew);
}

//结果
转换前的数据：[a,b,c,d, e,f,g,h]
转换后后的数据：[a, b, c, d, e, f, g, h]
    
    
//案列三:将集合里的元素由小写变大写：List<String> list = Arrays.asList("a", "b", "c", "d");
List<String> results = list.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println(results);

//结果
{A, B, C, D}

//案列四:每个员工工资加3000
public static void main(String[] args) {

    List<Person> personList = new ArrayList<Person>();
    personList.add(new Person(1, "zhangsan", 18, 4000, "shanghai"));
    personList.add(new Person(2, "lisi", 19, 5000, "beijing"));
    personList.add(new Person(3, "wanger", 20, 6000, "guangdong"));
    personList.add(new Person(4, "mazi", 21, 7000, "jiangxi"));
    personList.add(new Person(5, "laoer", 22, 8000, "zhejiang"));

    // 不改变原来员工工资集合的方式
    List<Person> personListNew = personList.stream().map(person -> {
        Person personNew = new Person(0, person.getName(), 0, 0, null);
        personNew.setSalary(person.getSalary() + 3000);
        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() + 3000);
        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());
}

@Data
static class Person {
    private int id;
    private String name;
    private int age;
    private int salary;
    private String address;

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

//结果
一次改动前：zhangsan-->4000
一次改动后：zhangsan-->7000
二次改动前：zhangsan-->7000
二次改动后：zhangsan-->7000

4.6排序(sorted)
sorted，中间操作。有两种排序：

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

public static void main(String[] args) {

    List<Person> personList = new ArrayList<Person>();
    personList.add(new Person(1, "zhangsan", 18, 4000, "shanghai"));
    personList.add(new Person(2, "lisi", 19, 5000, "beijing"));
    personList.add(new Person(3, "wanger", 20, 6000, "guangdong"));
    personList.add(new Person(4, "mazi", 21, 7000, "jiangxi"));
    personList.add(new Person(5, "laoer", 22, 8000, "zhejiang"));

    //工资排序顺序
    List<Person> collect1 = personList.stream().sorted(Comparator.comparing(Person::getSalary)).collect(Collectors.toList());
    collect1.forEach(System.out::println);
}

//结果
test12.Person(id=1, name=zhangsan, age=18, salary=4000, address=shanghai)
test12.Person(id=2, name=lisi, age=19, salary=5000, address=beijing)
test12.Person(id=3, name=wanger, age=20, salary=6000, address=guangdong)
test12.Person(id=4, name=mazi, age=21, salary=7000, address=jiangxi)
test12.Person(id=5, name=laoer, age=22, salary=8000, address=zhejiang)

sorted排序参考模板

//返回 对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));
//返回 对象集合以类属性一降序排序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序
//返回 对象集合以类属性一升序 属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));

//返回 对象集合以类属性一降序 属性二升序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序

//返回 对象集合以类属性一降序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序
//返回 对象集合以类属性一升序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序