万字详解Stream流以及Lambda（看这一篇就够用）

落日映苍穹つ 2024-03-25 20:20 33阅读 0赞

#### 目录 ####

*  什么是Stream流？
 *  如何使用Stream流？
 *   *  1.获取数据源
     *  2.转换为流
     *  3.中间操作
     *   *  过滤数据
         *  映射数据
         *  排序数据
         *  去重数据
     *  4.终止操作
     *   *  收集数据
         *  计数数据
         *  查找数据
         *  匹配数据
 *  如何使用Lambda表达式？
 *   *  1.使用Lambda表达式作为参数
     *  2.使用Lambda表达式实现函数接口
     *  3.使用Lambda表达式简化集合操作
     *   *  3.1 筛选操作
         *  3.2 映射操作
         *  3.3 排序操作
         *  3.4 去重操作
     *  Stream流和Lambda表达式的优点
 *  结论

## 什么是Stream流？ ##

Stream流是Java 8中新增的一种处理集合数据的方式，它提供了一种类似于数据库操作的流式处理方式，可以对集合进行过滤、映射、排序、聚合等操作，使得集合操作更加简洁、高效。

Stream流主要有以下几个特点：

*  Stream流不是数据结构，不会改变源数据，而是通过对源数据的操作来产生新的数据流。
 *  Stream流支持链式操作，可以进行多个操作的组合，使得代码更加简洁。
 *  Stream流支持延迟操作，只有在终止操作时才会进行计算，可以提高程序的性能。
 *  Stream流可以进行并行操作，利用多核处理器的性能优势，提高程序的计算速度。

## 如何使用Stream流？ ##

使用Stream流可以分为以下几个步骤：

1.  获取数据源：可以通过集合、数组、IO流等方式获取数据源。
2.  转换为流：通过stream()、parallelStream()等方法将数据源转换为流。
3.  中间操作：对流进行中间操作，如过滤、映射、排序、去重等操作，这些操作会返回一个新的流。
4.  终止操作：对流进行终止操作，如收集、计数、查找、匹配等操作，这些操作会返回一个结果。

下面将分别介绍各个操作的方法和使用示例。

### 1.获取数据源 ###

可以通过集合、数组、IO流等方式获取数据源。

使用集合获取数据源

List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon");

使用数组获取数据源

String[] array = {
        "apple", "banana", "orange", "grape", "watermelon"};

### 2.转换为流 ###

通过stream()、parallelStream()等方法将数据源转换为流。

将集合转换为流

List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon");
    Stream<String> stream = list.stream();

将数组转换为流

String[] array = {
        "apple", "banana", "orange", "grape", "watermelon"};
    Stream<String> stream = Arrays.stream(array);

### 3.中间操作 ###

对流进行中间操作，如过滤、映射、排序、去重等操作，这些操作会返回一个新的流。

#### 过滤数据 ####

过滤掉长度小于等于5的字符串：

List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon");
    Stream<String> stream = list.stream().filter(str -> str.length() > 5);

#### 映射数据 ####

提取出所有水果的名称：

List<Fruit> fruits = Arrays.asList(
        new Fruit("apple", "red"),
        new Fruit("banana", "yellow"),
        new Fruit("orange", "orange"),
        new Fruit("grape", "purple"),
        new Fruit("watermelon", "green")
    );
    Stream<String> stream = fruits.stream().map(Fruit::getName);

#### 排序数据 ####

按照水果名称进行排序：

List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon");
    Stream<String> stream = list.stream().sorted();

#### 去重数据 ####

去掉重复的水果名称：

List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon", "apple", "banana");
    Stream<String> stream = list.stream().distinct();

### 4.终止操作 ###

对流进行终止操作，如收集、计数、查找、匹配等操作，这些操作会返回一个结果。

#### 收集数据 ####

将水果名称收集到一个列表中：

List<Fruit> fruits = Arrays.asList(
        new Fruit("apple", "red"),
        new Fruit("banana", "yellow"),
        new Fruit("orange", "orange"),
        new Fruit("grape", "purple"),
        new Fruit("watermelon", "green")
    );
    List<String> names = fruits.stream().map(Fruit::getName).collect(Collectors.toList());

#### 计数数据 ####

统计水果名称的数量：

List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon", "apple", "banana");
    long count = list.stream().count();

#### 查找数据 ####

查找第一个水果名称：

List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon");
    Optional<String> first = list.stream().findFirst();

#### 匹配数据 ####

判断是否包含某个水果名称：

List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon");
    boolean contains = list.stream().anyMatch(str -> str.equals("banana"));

## 如何使用Lambda表达式？ ##

Lambda表达式可以在函数接口中使用，函数接口是指只包含一个抽象方法的接口。

Lambda表达式的基本语法：

(parameters) -> expression

其中，parameters为方法的参数列表，expression为方法体。

下面将分别介绍Lambda表达式的使用示例。

### 1.使用Lambda表达式作为参数 ###

将Lambda表达式作为参数传递给另一个方法：

public void process(int num, IntConsumer consumer) {
        
        consumer.accept(num);
    }
    
    public static void main(String[] args) {
        
        LambdaExample example = new LambdaExample();
    
        // 使用Lambda表达式作为参数
        example.process(10, (num) -> System.out.println(num));
    
        // 使用Lambda表达式实现函数接口
        Function<Integer, Integer> square = (num) -> num * num;
        int result = square.apply(5);
        System.out.println(result);
    
        // 使用Lambda表达式简化集合操作
        List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon");
    
        // 使用Lambda表达式实现筛选
        List<String> filteredList = list.stream().filter(str -> str.length() > 5).collect(Collectors.toList());
    
        // 使用Lambda表达式实现映射
        List<String> mappedList = list.stream().map(str -> str.toUpperCase()).collect(Collectors.toList());
    
        // 使用Lambda表达式实现排序
        List<String> sortedList = list.stream().sorted().collect(Collectors.toList());
    
        // 使用Lambda表达式实现去重
        List<String> distinctList = list.stream().distinct().collect(Collectors.toList());
    }

### 2.使用Lambda表达式实现函数接口 ###

使用Lambda表达式实现一个函数接口：

Function<Integer, Integer> square = (num) -> num * num;

### 3.使用Lambda表达式简化集合操作 ###

Lambda表达式可以简化集合操作，如筛选、映射、排序、去重等操作。下面是一些常见的集合操作示例：

#### 3.1 筛选操作 ####

筛选操作可以通过filter方法实现，它可以根据条件筛选集合中的元素，并返回一个新的Stream流。例如，下面是一个筛选操作的示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    List<Integer> evenNumbers = numbers.stream()
                                        .filter(n -> n % 2 == 0)
                                        .collect(Collectors.toList());
    System.out.println(evenNumbers); // [2, 4, 6, 8, 10]

该示例中，首先创建一个包含整数1到10的List集合，然后使用Stream流的filter方法筛选出其中的偶数，并将结果保存到一个新的List集合中。

#### 3.2 映射操作 ####

映射操作可以通过map方法实现，它可以将集合中的元素映射为另一个元素，并返回一个新的Stream流。例如，下面是一个映射操作的示例：

List<String> words = Arrays.asList("hello", "world", "java", "stream", "lambda");
    List<Integer> lengths = words.stream()
                                    .map(String::length)
                                    .collect(Collectors.toList());
    System.out.println(lengths); // [5, 5, 4, 6, 6]

该示例中，首先创建一个包含字符串的List集合，然后使用Stream流的map方法将每个字符串映射为它的长度，并将结果保存到一个新的List集合中。

#### 3.3 排序操作 ####

排序操作可以通过sorted方法实现，它可以对集合中的元素进行排序，并返回一个新的Stream流。例如，下面是一个排序操作的示例：

List<String> words = Arrays.asList("hello", "world", "java", "stream", "lambda");
    List<String> sortedWords = words.stream()
                                        .sorted()
                                        .collect(Collectors.toList());
    System.out.println(sortedWords); // [hello, java, lambda, stream, world]

该示例中，首先创建一个包含字符串的List集合，然后使用Stream流的sorted方法对字符串进行排序，并将结果保存到一个新的List集合中。

#### 3.4 去重操作 ####

去重操作可以通过distinct方法实现，它可以将集合中重复的元素去除，并返回一个新的Stream流。例如，下面是一个去重操作的示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 5, 4, 6, 7, 5);
    List<Integer> distinctNumbers = numbers.stream()
                                                .distinct()
                                                .collect(Collectors.toList());
    System.out.println(distinctNumbers); // [1, 2, 3, 4

**Lambda表达式的使用场景**  
Lambda表达式适合处理以下场景：

*  函数式接口：Lambda表达式可以作为函数式接口的实现。函数式接口只包含一个抽象方法的接口，可以使用Lambda表达式来实现该方法。
 *  集合操作：Stream流可以用于处理集合中的元素，如筛选、映射、排序、去重等操作，可以使用Lambda表达式来简化代码。
 *  多线程编程：Lambda表达式可以作为Runnable和Callable接口的实现，可以更方便地实现多线程编程。
 *  GUI事件监听器：Lambda表达式可以用于处理GUI事件监听器中的事件处理方法，可以使得代码更加简洁。

### Stream流和Lambda表达式的优点 ###

使用Stream流和Lambda表达式有以下优点：

1.  简洁：使用Stream流和Lambda表达式可以使代码更加简洁、可读，降低代码的复杂度。
2.  易于维护：使用Stream流和Lambda表达式可以使代码更加易于维护，减少代码的重复性。
3.  并发执行：Stream流可以支持并发执行，提高程序的执行效率。
4.  高效：使用Stream流和Lambda表达式可以使代码更加高效，减少内存和CPU的开销。

## 结论 ##

Stream流和Lambda表达式是Java 8中的两个重要特性，它们可以使得代码更加简洁、可读、灵活，同时可以提高代码的效率和可维护性。如果您还没有使用过Stream流和Lambda表达式，那么希望这篇教程能够帮助您入门。