AI 助理
备案控制台
开发者社区 云计算 文章 正文

Stream流

2024-01-25 51
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Stream流

 数据准备

创建实体类Author

package com.zsh.stream.domain.po;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode// 用于后期的去重使用
public class Author {
    // id
    private Long id;
    // 姓名
    private String name;
    // 年龄
    private Integer age;
    // 简介
    private String intro;
    // 作品
    private List<Book> books;
}

image.gif

创建实体类Book

package com.zsh.stream.domain.po;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode// 用于后期的去重使用
public class Book {
    // id
    private Long id;
    // 书名
    private String name;
    // 分类
    private String category;
    // 评分
    private Integer score;
    // 简介
    private String Intro;
}

image.gif

创建测试类

package com.zsh.stream.demo;
import com.zsh.stream.domain.po.Author;
import com.zsh.stream.domain.po.Book;
import java.util.*;
import java.util.stream.Stream;
public class StreamDemo {
    /**
     * 数据准备
     * @return
     */
    private static List<Author> getAuthors() {
        // 数据初始化
        Author author1 = new Author(1L, "开朗觉觉", 16, "30年超级Java开发工程师", null);
        Author author2 = new Author(1L, "开朗觉觉", 16, "30年超级Java开发工程师", null);
        Author author3 = new Author(3L, "小美", 17, "10年超级Java开发工程师", null);
        Author author4 = new Author(4L, "觉觉", 19, "5年超级Java开发工程师", null);
        // 书籍列表
        ArrayList<Book> books1 = new ArrayList<>();
        ArrayList<Book> books2 = new ArrayList<>();
        ArrayList<Book> books3 = new ArrayList<>();
        books1.add(new Book(1L,"晨岛快速跑图攻略1","哲学",88,"123123"));
        books1.add(new Book(2L,"晨岛快速跑图攻略2","哲学",88,"123123"));
        books1.add(new Book(3L,"晨岛快速跑图攻略2","哲学",88,"123123"));
        books2.add(new Book(1L,"晨岛快速跑图攻略1","哲学",88,"123123"));
        books2.add(new Book(2L,"晨岛快速跑图攻略2","哲学",88,"123123"));
        books2.add(new Book(3L,"晨岛快速跑图攻略2","哲学",88,"123123"));
        books3.add(new Book(7L,"晨岛快速跑图攻略3","哲学",88,"123123"));
        books3.add(new Book(8L,"晨岛快速跑图攻略3","哲学",88,"123123"));
        books3.add(new Book(9L,"晨岛快速跑图攻略3","哲学",88,"123123"));
        author1.setBooks(books1);
        author2.setBooks(books2);
        author3.setBooks(books3);
        author4.setBooks(books3);
        ArrayList<Author> authorList = new ArrayList<>(Arrays.asList(author1,author2,author3,author4));
        return authorList;
    }
}

image.gif

入门测试

打印年龄小于18的作家名字，并且去重

public class StreamDemo {
    public static void main(String[] args) {
        // 打印年龄小于18的作家名字，并且去重
        test1();
    }
    /**
     * 打印年龄小于18的作家名字，并且去重
     */
    private static void test1() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 打印年龄小于18的作家名字，并且去重
        authors.stream()    // 把集合转换成流
                // 去重
                .distinct()
                // 筛选
                .filter(author -> author.getAge() < 18)
                // 打印
                .forEach(author -> System.out.println(author.getName()));
    }
}

image.gif

单列集合创建流(重要)

public class StreamDemo {
    public static void main(String[] args) {
        // 单列集合创建流(重要)
        test2();
    }
    /**
     * 单列集合创建流
     */
    private static void test2() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 单列集合创建流
        Stream<Author> stream = authors.stream();
    }
}

image.gif

数组创建流

public class StreamDemo {
    public static void main(String[] args) {
        // 数组创建流(方式1)
        test3();
        // 数组创建流(方式2)
        test4();
    }
    /**
     * 数组创建流(方式2)
     */
    private static void test4() {
        // 创建数组
        Integer[] numArr = {1,2,3,4,5};
        // 数组创建流
        Stream<Integer> stream = Stream.of(numArr);
        // 输出
        stream.filter(integer -> integer > 2)
                .forEach(integer -> System.out.println(integer));
    }
    /**
     * 数组创建流(方式1)
     */
    private static void test3() {
        // 创建数组
        Integer[] numArr = {1,2,3,4,5};
        // 数组创建流
        Stream<Integer> stream = Arrays.stream(numArr);
        // 输出
        stream.filter(integer -> integer % 2 == 0)
                .forEach(integer -> System.out.println(integer));
    }
}

image.gif

Map创建流

public class StreamDemo {
    public static void main(String[] args) {
        // Map创建流
        test5();
    }
    /**
     * Map创建流
     */
    private static void test5() {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("开朗觉觉",16);
        map.put("开朗莽莽",17);
        map.put("酪小美",18);
        // 将Map集合转换为Set集合 (Map集合是不能直接转换为Stream流的，所以要先转成Set集合)
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        // 创建Stream流
        Stream<Map.Entry<String, Integer>> stream = entrySet.stream();
        // 输出
        stream.filter(item -> item.getValue() == 18)
                .forEach(item -> System.out.println(item.getKey() + "," + item.getValue() + "岁"));
    }
}

image.gif

中间操作常用方法

filter() 根据条件进行过滤

public class StreamCenter {
    public static void main(String[] args) {
        // filter() 打印所有名字长度大于2的作家姓名
        test1();
    }
    /**
     * filter() 打印所有名字长度大于2的作家姓名
     */
    private static void test1() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 获取流并打印
        authors.stream()
                .distinct()
                .filter(author -> author.getName().length() > 2)
                .forEach(author -> System.out.println(author.getName()));
    }
}

image.gif

map() 将流中的元素进行转换

public class StreamCenter {
    public static void main(String[] args) {
        // map() 将流中的元素进行转换
        test2();
    }
    /**
     * map() 将流中的元素进行转换
     */
    private static void test2() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 创建流并输出
        authors.stream()
                .map(author -> author.getName())
                .forEach(name -> System.out.println(name));
    }
}

image.gif

map() 将流中元素进行计算

public class StreamCenter {
    public static void main(String[] args) {
        // map() 将流中元素进行计算
        test3();
    }
    /**
     * map() 将流中元素进行计算
     */
    private static void test3() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 创建流并输出
        authors.stream()
                .map(author -> author.getAge())
                .map(age -> age + 10)
                .forEach(System.out::println);
    }
}

image.gif

distinct() 去除重复元素

注意：distinct方法是依赖Object的equals方法来判断是否是相同对象的。所以注意重写equals方法；

public class StreamCenter {
    public static void main(String[] args) {
        // distinct() 去除重复元素 (distinct方法是依赖Object的equals方法来判断是否是相同对象的。所以注意重写equals方法)
        test4();
    }
    /**
     * distinct() 去除重复元素 (distinct方法是依赖Object的equals方法来判断是否是相同对象的。所以注意重写equals方法)
     */
    private static void test4() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 创建流并输出
        authors.stream()
                .distinct()
                .forEach(author -> System.out.println(author.getName()));
    }
}

image.gif

sorted() 对流中的元素进行排序

注意：如果调用空参的sorted方法，需要流中的元素是实现了Comparable;

public class StreamCenter {
    public static void main(String[] args) {
        // sorted() 对流中的元素按年龄进行排序 (注意如果调用空参的sorted方法，需要流中的元素是实现了Comparable)
        test5();
    }
    /**
     * sorted() 对流中的元素按年龄进行排序
     */
    private static void test5() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 创建流并输出
        authors.stream()
                .sorted((o1, o2) -> o1.getAge() - o2.getAge())
                .forEach(author -> System.out.println(author.getName() + "," + author.getAge()));
    }
}

image.gif

limit() 设置流的最大长度

注意：超出的部将被抛弃;

public class StreamCenter {
    public static void main(String[] args) {
        // limit() 对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素，然后打印其中两个年龄最大的作家
        test6();
    }
    /**
     * limit() 对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素，然后打印其中两个年龄最大的作家
     */
    private static void test6() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 创建流并输出
        authors.stream()
                .distinct()
                .sorted((o1, o2) -> o2.getAge() - o1.getAge())
                .limit(2)
                .forEach(author -> System.out.println(author.getName() + "," + author.getAge()));
    }
}

image.gif

skip() 跳过流中的几个元素

public class StreamCenter {
    public static void main(String[] args) {
        // skip() 跳过流中的几个元素
        test7();
    }
    // skip() 跳过流中的几个元素
    private static void test7() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 创建流并输出
        authors.stream()
                .skip(1)
                .forEach(author -> System.out.println(author.getName()));
    }
}

image.gif

flatMap() 将流中元素的多个对象作为流中的元素

public class StreamCenter {
    public static void main(String[] args) {
        // flatMap() 将流中元素的多个对象作为流中的元素
        test8();
    }
    /**
     * flatMap() 将流中元素的多个对象作为流中的元素
     */
    private static void test8() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 创建流并输出
        authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .forEach(book -> System.out.println(book.getName()));
    }
}

image.gif

打印现有数据的所有分类，要求去重，不能出现连着的分类：哲学，爱情

public class StreamCenter {
    public static void main(String[] args) {
        // 打印现有数据的所有分类，要求去重，不能出现连着的分类：哲学，爱情
        test9();
    }
    /**
     * 打印现有数据的所有分类，要求去重，不能出现连着的分类：哲学，爱情
     */
    private static void test9() {
        // 数据准备
        List<Author> authors = getAuthors();
        // 创建流并输出
        authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .flatMap(book -> Arrays.stream(book.getCategory().split("，")))
                .distinct()
                .forEach(category -> System.out.println(category));
    }
}

image.gif

 


开朗觉觉
目录
相关文章
算精通
|
1月前
|
存储 JavaScript 网络协议
Stream
【10月更文挑战第22天】
算精通
30 1
舒一笑
|
6月前
|
存储 Java API
Stream流
Stream流
舒一笑
64 1
杀死一只知更鸟debug
|
2月前
|
Java 数据处理
Stream流的简单使用
这篇文章介绍了Java中Stream流的基本概念和使用方法。文章解释了Stream流的三类方法：获取流、中间方法和终结方法。详细讨论了如何生成Stream流，包括从Collection体系集合、Map体系集合、数组和同种数据类型的多个数据中生成流。接着，介绍了Stream流的中间操作方法，如`filter`、`limit`、`skip`、`concat`和`distinct`。文章还讨论了Stream流的终结方法，如`forEach`和`count`，以及收集方法，如`collect`。最后，通过几个例子演示了如何使用Stream流进行数据处理和收集操作。
杀死一只知更鸟debug
57 0
不摸鱼的程序员
|
6月前
|
Java 容器
Stream 流常见基本操作
Stream 流常见基本操作
不摸鱼的程序员
77 2
_殊途
|
5月前
|
API
Stream流知识
Stream流知识
_殊途
32 0
sky_qiyi
|
5月前
|
存储 Java API
Java——Stream流（1/2）：Stream流入门、Stream流的创建（认识Stream、体验Stream流、Stream流的使用步骤、获取Stream流的方法）
Java——Stream流（1/2）：Stream流入门、Stream流的创建（认识Stream、体验Stream流、Stream流的使用步骤、获取Stream流的方法）
sky_qiyi
83 0
游客repv2zmhyosc2
|
6月前
Stream
a
游客repv2zmhyosc2
42 2
星辰破晓
|
Java
stream流操作
stream流操作
星辰破晓
75 0
懒鱼七忆
|
6月前
|
Java
Stream流教程
Stream流教程
懒鱼七忆
72 0
快乐阿超
|
Java
stream流分组
stream流分组
快乐阿超
89 0