当前位置：首页 > 文章列表 > 文章 > java教程 > JavaStream属性筛选技巧

JavaStream属性筛选技巧

2025-12-14 23:36:35 0浏览收藏

本篇文章给大家分享《Java Stream高效筛选：基于属性交集的列表处理》，覆盖了文章的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

使用Java Stream API高效筛选复杂对象列表：基于属性值集合的交集操作

本文旨在指导读者如何利用Java Stream API，高效地从一个包含复杂自定义对象的列表中筛选出符合特定条件的元素。核心方法是将用于匹配的字符串属性列表转换为`HashSet`，以实现O(1)的平均时间复杂度查找，并结合Stream API的`filter`操作，从而优化筛选复杂对象属性与给定集合的交集性能。

在现代Java应用开发中，处理集合数据是日常任务。当需要从一个包含复杂自定义对象的列表中，根据其某个特定属性值是否存在于另一个字符串集合中来筛选对象时，高效的解决方案至关重要。本教程将详细介绍如何使用Java Stream API结合HashSet的优势来实现这一目标。

1. 定义数据模型

首先，我们需要定义用于示例的领域对象。假设我们有两个类：Location（位置）和 Address（地址），其中 Location 包含一个 Address 对象，而 Address 包含 street（街道）和 number（门牌号）等属性。为了遵循Java的良好实践，我们将使用访问修饰符和getter方法来封装数据。

import java.util.Objects;

public class Address {
    private String street;
    private String number; // 门牌号

    public Address(String street, String number) {
        this.street = street;
        this.number = number;
    }

    public String getStreet() {
        return street;
    }

    public String getNumber() {
        return number;
    }

    // 建议重写equals和hashCode，以便在集合操作中正确比较对象
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(street, address.street) &&
               Objects.equals(number, address.number);
    }

    @Override
    public int hashCode() {
        return Objects.hash(street, number);
    }

    @Override
    public String toString() {
        return "Address{" +
               "street='" + street + '\'' +
               ", number='" + number + '\'' +
               '}';
    }
}

import java.util.Objects;

public class GPS {
    private double latitude;
    private double longitude;

    public GPS(double latitude, double longitude) {
        this.latitude = latitude;
        this.longitude = longitude;
    }

    public double getLatitude() {
        return latitude;
    }

    public double getLongitude() {
        return longitude;
    }

    @Override
    public String toString() {
        return "GPS{" +
               "latitude=" + latitude +
               ", longitude=" + longitude +
               '}';
    }
}

import java.util.Objects;

public class Location {
    private GPS gps;
    private Address address;

    public Location(GPS gps, Address address) {
        this.gps = gps;
        this.address = address;
    }

    public GPS getGps() {
        return gps;
    }

    public Address getAddress() {
        return address;
    }

    @Override
    public String toString() {
        return "Location{" +
               "gps=" + gps +
               ", address=" + address +
               '}';
    }
}

2. 准备查找集合

假设我们有一个List，其中包含我们感兴趣的门牌号。为了高效地判断某个门牌号是否存在于这个列表中，我们应该将其转换为HashSet。HashSet提供了平均O(1)时间复杂度的contains()方法，相比ArrayList的O(n)效率更高，尤其是在处理大量数据时，性能优势显著。

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

// 假设这是我们感兴趣的门牌号列表
List houseNumbersList = Arrays.asList("101", "205", "303", "410");

// 将List转换为HashSet，提高查找效率
Set targetHouseNumbers = new HashSet<>(houseNumbersList);

System.out.println("目标门牌号集合: " + targetHouseNumbers);

3. 使用Stream API进行过滤

现在，我们拥有一个List和一个Set，目标是筛选出Location对象中address.number属性值存在于targetHouseNumbers集合中的所有Location。我们将使用Java Stream API的filter操作来完成这项任务。

filter()是一个中间操作，它接收一个Predicate函数式接口，用于定义筛选条件。对于每个流中的元素，如果Predicate返回true，则该元素会被保留；否则，它将被丢弃。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors; // JDK 15及以下版本需要

public class LocationFilterTutorial {

    public static void main(String[] args) {
        // 1. 准备数据模型 (已在上面定义)

        // 2. 准备目标门牌号集合
        List houseNumbersList = Arrays.asList("101", "205", "303", "410");
        Set targetHouseNumbers = new HashSet<>(houseNumbersList);

        // 3. 准备Location列表
        List locations = new ArrayList<>();
        locations.add(new Location(new GPS(34.0, -118.0), new Address("Main St", "101")));
        locations.add(new Location(new GPS(34.1, -118.1), new Address("Elm St", "102")));
        locations.add(new Location(new GPS(34.2, -118.2), new Address("Oak Ave", "205")));
        locations.add(new Location(new GPS(34.3, -118.3), new Address("Pine Ln", "300")));
        locations.add(new Location(new GPS(34.4, -118.4), new Address("Maple Dr", "410")));
        locations.add(new Location(new GPS(34.5, -118.5), new Address("Cedar Rd", "500")));
        locations.add(new Location(new GPS(34.6, -118.6), new Address("Birch Blvd", "205")));

        System.out.println("原始Location列表:");
        locations.forEach(System.out::println);
        System.out.println("--------------------");

        // 4. 使用Stream API进行过滤和收集结果
        List filteredLocations = locations.stream()
                .filter(location -> targetHouseNumbers.contains(location.getAddress().getNumber()))
                // Java 16+ 可以直接使用 .toList();
                // Java 15及以下版本使用 .collect(Collectors.toList());
                .collect(Collectors.toList()); // 或 .toList() for Java 16+

        System.out.println("过滤后的Location列表:");
        filteredLocations.forEach(System.out::println);
    }
}

代码解析：

locations.stream(): 将List转换为一个Stream。
.filter(location -> targetHouseNumbers.contains(location.getAddress().getNumber())): 这是核心过滤逻辑。
- 对于流中的每个Location对象，我们通过location.getAddress().getNumber()获取其门牌号。
- 然后，使用targetHouseNumbers.contains()方法检查这个门牌号是否存在于我们的目标HashSet中。
- 如果contains()返回true，则该Location对象会被保留到下一个操作；如果返回false，则被丢弃。
.collect(Collectors.toList()) (或 .toList() for Java 16+): 这是一个终端操作，用于将过滤后的流中的所有元素收集到一个新的List中。

注意事项

封装性（Encapsulation）：在Java中，推荐使用getter方法（如getAddress().getNumber()）来访问对象的内部属性，而不是直接访问字段（如location.address.number）。这符合面向对象编程的封装原则，有助于维护数据完整性和代码的可读性。
性能优化：对于大型数据集，将查找列表转换为HashSet是关键的性能优化手段。如果查找列表非常小，ArrayList.contains()的性能影响可能不明显，但养成使用HashSet的习惯对于处理未来可能扩展的数据量非常有益。
JDK版本兼容性：
- 对于Java 16及更高版本，可以使用stream().toList()作为更简洁的收集操作。
- 对于Java 15及更早版本，必须使用stream().collect(Collectors.toList())。