Java 数组过滤：基础与实践

简介

在 Java 编程中，数组过滤是一项常见且重要的操作。它允许我们从数组中筛选出满足特定条件的元素，从而得到一个只包含所需元素的新数组。本文将详细介绍 Java 中数组过滤的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效使用数组过滤功能。

基础概念

数组过滤是指从一个数组中选择满足特定条件的元素，形成一个新的数组。这个条件可以是任何逻辑判断，比如元素大于某个值、元素包含特定字符串等。在 Java 中，实现数组过滤有多种方式，不同的方式适用于不同的场景。

使用方法

传统方式

在 Java 8 之前，我们通常使用循环来遍历数组，根据条件筛选元素，并将满足条件的元素添加到一个新的数组中。以下是一个示例代码：

import java.util.ArrayList;
import java.util.List;

public class TraditionalArrayFilter {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        List<Integer> filteredList = new ArrayList<>();

        for (int num : originalArray) {
            if (num % 2 == 0) {
                filteredList.add(num);
            }
        }

        int[] filteredArray = new int[filteredList.size()];
        for (int i = 0; i < filteredList.size(); i++) {
            filteredArray[i] = filteredList.get(i);
        }

        for (int num : filteredArray) {
            System.out.print(num + " ");
        }
    }
}

在这个示例中，我们首先创建了一个整数数组 originalArray，然后使用 for-each 循环遍历数组，将偶数添加到 filteredList 中。最后，我们将 filteredList 转换为一个新的整数数组 filteredArray。

Java 8 Stream API

Java 8 引入了 Stream API，它提供了一种更简洁、更函数式的方式来处理数组过滤。以下是使用 Stream API 实现相同功能的示例代码：

import java.util.Arrays;

public class StreamArrayFilter {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int[] filteredArray = Arrays.stream(originalArray)
                                   .filter(num -> num % 2 == 0)
                                   .toArray();

        Arrays.stream(filteredArray).forEach(num -> System.out.print(num + " "));
    }
}

在这个示例中，我们使用 Arrays.stream() 方法将数组转换为一个流，然后使用 filter() 方法筛选出偶数，最后使用 toArray() 方法将流转换为一个新的数组。

常见实践

过滤数字数组

过滤数字数组是最常见的数组过滤场景之一。以下是一个过滤出大于 5 的整数的示例代码：

import java.util.Arrays;

public class FilterNumberArray {
    public static void main(String[] args) {
        int[] originalArray = {1, 3, 6, 8, 2, 9, 4};
        int[] filteredArray = Arrays.stream(originalArray)
                                   .filter(num -> num > 5)
                                   .toArray();

        Arrays.stream(filteredArray).forEach(num -> System.out.print(num + " "));
    }
}

过滤对象数组

除了数字数组，我们还经常需要过滤对象数组。以下是一个过滤出年龄大于 18 岁的人的示例代码：

import java.util.Arrays;

class Person {
    private String name;
    private int age;

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

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class FilterObjectArray {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 20),
            new Person("Bob", 15),
            new Person("Charlie", 25)
        };

        Person[] filteredPeople = Arrays.stream(people)
                                        .filter(person -> person.getAge() > 18)
                                        .toArray(Person[]::new);

        Arrays.stream(filteredPeople).forEach(System.out::println);
    }
}

最佳实践

性能优化

在处理大规模数组时，性能是一个重要的考虑因素。使用 Stream API 可以提供一定的性能优化，因为它支持并行处理。以下是一个使用并行流处理大规模数组的示例代码：

import java.util.Arrays;

public class ParallelStreamFilter {
    public static void main(String[] args) {
        int[] largeArray = new int[1000000];
        for (int i = 0; i < largeArray.length; i++) {
            largeArray[i] = i;
        }

        int[] filteredArray = Arrays.stream(largeArray)
                                   .parallel()
                                   .filter(num -> num % 2 == 0)
                                   .toArray();

        System.out.println("Filtered array size: " + filteredArray.length);
    }
}

在这个示例中，我们使用 parallel() 方法将流转换为并行流，从而利用多核处理器的优势提高过滤性能。

代码可读性

代码可读性也是一个重要的方面。使用 Stream API 可以使代码更简洁、更易读。以下是一个使用方法引用提高代码可读性的示例代码：

import java.util.Arrays;

class Employee {
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Employee{name='" + name + "', salary=" + salary + "}";
    }
}

public class ReadableCodeFilter {
    public static void main(String[] args) {
        Employee[] employees = {
            new Employee("Alice", 5000),
            new Employee("Bob", 6000),
            new Employee("Charlie", 4000)
        };

        Employee[] highSalaryEmployees = Arrays.stream(employees)
                                               .filter(Employee::hasHighSalary)
                                               .toArray(Employee[]::new);

        Arrays.stream(highSalaryEmployees).forEach(System.out::println);
    }
}

// 在 Employee 类中添加 hasHighSalary 方法
class Employee {
    // ... 之前的代码 ...

    public boolean hasHighSalary() {
        return salary > 5000;
    }
}

在这个示例中，我们使用方法引用 Employee::hasHighSalary 来替代 Lambda 表达式，使代码更简洁、更易读。

小结

本文介绍了 Java 中数组过滤的基础概念、使用方法、常见实践以及最佳实践。我们学习了传统方式和 Java 8 Stream API 两种实现数组过滤的方法，以及如何过滤数字数组和对象数组。同时，我们还讨论了性能优化和代码可读性方面的最佳实践。通过掌握这些知识，读者可以更高效地使用数组过滤功能，提高 Java 编程的效率和质量。