Java Stream面试问题全解析

简介

在Java的世界里，Stream API是一个强大且实用的功能，它极大地简化了集合数据的处理。在面试中，关于Java Stream的问题屡见不鲜，理解其基础概念、掌握使用方法以及了解常见和最佳实践，对于求职者来说至关重要。本文将围绕Java Stream面试问题展开深入探讨，帮助读者全面掌握相关知识。

目录

1. 基础概念
2. 使用方法
   • 创建Stream
   • 中间操作
   • 终端操作
3. 常见实践
   • 过滤数据
   • 映射数据
   • 聚合操作
4. 最佳实践
   • 性能优化
   • 避免常见错误
5. 小结
6. 参考资料

基础概念

Java Stream是Java 8引入的一个新特性，它提供了一种函数式编程风格来处理集合数据。Stream代表了一系列支持顺序和并行聚合操作的元素序列。与传统的集合操作不同，Stream操作不会修改源数据，而是返回一个新的结果。

Stream有三个关键部分： - 数据源：可以是集合、数组等。 - 中间操作：对Stream进行转换，返回一个新的Stream，例如过滤、映射等操作。 - 终端操作：触发Stream的处理，并返回最终结果，例如计数、收集等操作。

使用方法

创建Stream

1. 从集合创建

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

public class StreamCreation {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        Stream<String> streamFromList = list.stream();
        Stream<String> parallelStreamFromList = list.parallelStream();
    }
}

1. 从数组创建

import java.util.stream.Stream;

public class StreamCreation {
    public static void main(String[] args) {
        String[] array = {"apple", "banana", "cherry"};
        Stream<String> streamFromArray = Arrays.stream(array);
    }
}

中间操作

1. 过滤（filter）：根据条件过滤元素。

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

public class FilterOperation {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> evenNumbers = numbers.stream()
              .filter(num -> num % 2 == 0)
              .collect(Collectors.toList());
        System.out.println(evenNumbers);
    }
}

1. 映射（map）：将一个元素转换为另一个元素。

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

public class MapOperation {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        List<Integer> wordLengths = words.stream()
              .map(String::length)
              .collect(Collectors.toList());
        System.out.println(wordLengths);
    }
}

终端操作

1. 计数（count）：返回Stream中的元素数量。

import java.util.Arrays;
import java.util.List;

public class CountOperation {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        long count = numbers.stream()
              .count();
        System.out.println(count);
    }
}

1. 收集（collect）：将Stream中的元素收集到一个集合中。

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

public class CollectOperation {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> squaredNumbers = numbers.stream()
              .map(num -> num * num)
              .collect(Collectors.toList());
        System.out.println(squaredNumbers);
    }
}

常见实践

过滤数据

在处理大量数据时，过滤出符合特定条件的数据是常见需求。例如，从用户列表中过滤出年龄大于30岁的用户。

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

class User {
    private String name;
    private int age;

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

    public int getAge() {
        return age;
    }
}

public class FilterUsers {
    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        users.add(new User("Alice", 25));
        users.add(new User("Bob", 35));
        users.add(new User("Charlie", 40));

        List<User> filteredUsers = users.stream()
              .filter(user -> user.getAge() > 30)
              .collect(Collectors.toList());
        System.out.println(filteredUsers.size());
    }
}

映射数据

将一种类型的数据转换为另一种类型，比如将字符串列表转换为大写形式。

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

public class MapStrings {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("hello", "world");
        List<String> upperCaseWords = words.stream()
              .map(String::toUpperCase)
              .collect(Collectors.toList());
        System.out.println(upperCaseWords);
    }
}

聚合操作

计算集合中的总和、平均值等。例如，计算整数列表的总和。

import java.util.Arrays;
import java.util.List;

public class Aggregation {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
              .mapToInt(Integer::intValue)
              .sum();
        System.out.println(sum);
    }
}

最佳实践

性能优化

1. 使用并行流：对于大规模数据处理，并行流可以显著提高性能。但要注意，并行流在数据量较小时可能会带来额外开销。

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

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> squaredNumbers = numbers.parallelStream()
              .map(num -> num * num)
              .collect(Collectors.toList());
        System.out.println(squaredNumbers);
    }
}

1. 避免不必要的中间操作：尽量减少Stream中的中间操作链，避免复杂的嵌套操作，以提高性能。

避免常见错误

1. 不要在Stream操作中修改外部状态：Stream操作应该是无状态的，在操作中修改外部变量会导致不可预测的结果。
2. 正确使用终端操作：确保在适当的时候使用终端操作，因为中间操作只有在终端操作触发时才会执行。

小结

本文围绕Java Stream面试问题，详细介绍了其基础概念、使用方法、常见实践以及最佳实践。掌握这些知识，不仅能在面试中应对自如，更能在实际项目中高效地使用Stream API来处理数据。希望读者通过学习本文，对Java Stream有更深入的理解和应用能力。

参考资料

• Oracle官方Java 8文档
• 《Effective Java》第三版