• 3.4 常用操作

    3.4.1 创建流

    单列集合： 集合对象.stream()

            List<Author> authors = getAuthors();
        Stream<Author> stream = authors.stream();
        

    • 1
    • 2
    • 3

    在 Java 中，stream() 是集合类（如 List、Set、Map 等）提供的一个方法，用于获取一个流（Stream）。通过流，你可以使用更灵活的函数式编程方式对集合进行各种操作。

    下面是一个简单的示例，演示了如何使用 stream() 方法：

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

public class StreamExample {
    public static void main(String[] args) {
        // 创建一个列表
        List<String> words = Arrays.asList("hello", "world", "java", "stream");

        // 使用 stream() 方法获取流
        List<String> upperCaseWords = words.stream()
                .map(String::toUpperCase)  // 将每个元素转为大写
                .collect(Collectors.toList());  // 将结果收集为列表

        System.out.println("Original List: " + words);
        System.out.println("Modified List: " + upperCaseWords);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    在这个例子中，我们首先创建了一个包含字符串的列表 words，然后通过 stream() 方法获取了一个流。接着，我们使用 map 操作将每个字符串转为大写形式，最后使用 collect 操作将结果收集为一个新的列表。

    使用流的好处之一是可以通过链式操作轻松组合多个中间和终端操作，以实现对数据的处理。流提供了一种更函数式的编程风格，使得代码更简洁、可读性更好。

    数组：Arrays.stream(数组)或者使用Stream.of来创建

            Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream = Arrays.stream(arr);
        Stream<Integer> stream2 = Stream.of(arr);


    • 1
    • 2
    • 3
    • 4

    在 Java 中，你可以使用 Arrays.stream(数组) 或 Stream.of(数组) 来将数组转换为流（Stream）。这样可以方便地使用流的各种操作对数组进行处理。

    下面是使用这两种方法的示例：

    import java.util.Arrays;
import java.util.stream.Stream;

public class ArrayToStreamExample {
    public static void main(String[] args) {
        // 使用 Arrays.stream() 将数组转换为流
        int[] intArray = {1, 2, 3, 4, 5};
        Arrays.stream(intArray)
              .forEach(System.out::println);

        // 使用 Stream.of() 将数组转换为流
        String[] stringArray = {"apple", "banana", "orange"};
        Stream.of(stringArray)
              .forEach(System.out::println);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    在这个例子中，我们首先使用 Arrays.stream(intArray) 将整型数组转换为流，然后使用 forEach 输出流中的每个元素。接着，我们使用 Stream.of(stringArray) 将字符串数组转换为流，同样使用 forEach 输出每个元素。

    这种将数组转换为流的方式非常灵活，使得我们可以利用流的各种操作来处理数组中的元素，比如映射、过滤、排序等。

    双列集合：转换成单列集合后再创建

            Map<String,Integer> map = new HashMap<>();
        map.put("蜡笔小新",19);
        map.put("黑子",17);
        map.put("日向翔阳",16);
​
        Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    在 Java 中，如果你有一个双列集合（比如 Map）并希望将其转换成单列集合，你可以使用 entrySet() 方法获取到Map中所有的键值对（Entry 对象），然后再对这些键值对进行处理。这可以通过 stream() 方法来实现。

    以下是一个简单的示例，演示了如何将 Map 转换为包含所有键的列表：

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

public class MapToListExample {
    public static void main(String[] args) {
        // 创建一个Map
        Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 3);

        // 使用entrySet()获取键值对，然后将其转换为流，再进行处理
        List<String> keys = map.entrySet().stream()
                                .map(Map.Entry::getKey)
                                .collect(Collectors.toList());

        System.out.println("Original Map: " + map);
        System.out.println("Keys as List: " + keys);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这个例子中，entrySet() 方法返回一个包含键值对的Set，然后通过 stream() 方法将其转换为流。使用 map 操作将每个键值对映射为键（Entry::getKey），最后通过 collect 操作将结果收集为一个列表。

    这样，你就可以从双列集合中提取出其中的某一列，然后以单列集合的形式进行使用。

    3.4.2 中间操作

    filter

    可以对流中的元素进行条件过滤，符合过滤条件的才能继续留在流中。
    在这里插入图片描述

            List<Author> authors = getAuthors();
        authors.stream()
                .filter(author -> author.getName().length()>1)
                .forEach(author -> System.out.println(author.getName()));


    • 1
    • 2
    • 3
    • 4
    • 5

    map

    可以把对流中的元素进行计算或转换。
    在这里插入图片描述

            List<Author> authors = getAuthors();

        authors
                .stream()
                .map(author -> author.getName())
                .forEach(name->System.out.println(name));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    //        打印所有作家的姓名
        List<Author> authors = getAuthors();

//        authors.stream()
//                .map(author -> author.getName())
//                .forEach(s -> System.out.println(s));

        authors.stream()
                .map(author -> author.getAge())
                .map(age->age+10)
                .forEach(age-> System.out.println(age));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    distinct

    可以去除流中的重复元素。
    在这里插入图片描述

            List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .forEach(author -> System.out.println(author.getName()));


    • 1
    • 2
    • 3
    • 4
    • 5

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

    sorted

    可以对流中的元素进行排序。
    在这里插入图片描述

            List<Author> authors = getAuthors();
//        对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素。
        authors.stream()
                .distinct()
                .sorted()
                .forEach(author -> System.out.println(author.getAge()));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
            List<Author> authors = getAuthors();
//        对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素。
        authors.stream()
                .distinct()
                .sorted((o1, o2) -> o2.getAge()-o1.getAge())
                .forEach(author -> System.out.println(author.getAge()));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

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

    limit

    可以设置流的最大长度，超出的部分将被抛弃。
    在这里插入图片描述

            List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .sorted()
                .limit(2)
                .forEach(author -> System.out.println(author.getName()));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    skip

    跳过流中的前n个元素，返回剩下的元素
    在这里插入图片描述

    //        打印除了年龄最大的作家外的其他作家，要求不能有重复元素，并且按照年龄降序排序。
        List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .sorted()
                .skip(1)
                .forEach(author -> System.out.println(author.getName()));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    flatMap

    map只能把一个对象转换成另一个对象来作为流中的元素。而flatMap可以把一个对象转换成多个对象作为流中的元素。

    在这里插入图片描述

    //        打印所有书籍的名字。要求对重复的元素进行去重。
        List<Author> authors = getAuthors();

        authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .forEach(book -> System.out.println(book.getName()));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    在这里插入图片描述

    //        打印现有数据的所有分类。要求对分类进行去重。不能出现这种格式：哲学,爱情     爱情
        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));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
  • 相关阅读:
    计算机毕业设计之java+javaweb的超市库存管理系统
    Elasticsearch搜索引擎
    【05】Nginx之Rewrite功能配置
    CDH 01CentOS配置(markdown新版二)
    数据结构— — 二叉树的遍历
    初阶数据结构学习记录——다섯 双向循环链表
    数据集笔记：旧金山共享单车OD数据
    vxWorks armV8a 多核启动过程
    搭建神经网络（torch.nn的用法）
    自动化工具：PyAutoGUI的鼠标与键盘控制，解放双手的利器
  • 原文地址：https://blog.csdn.net/weixin_43554580/article/details/133809985