本文详细介绍了如何利用Java Stream API，结合`HashSet`的优化，高效地从一个包含复杂自定义对象（如`Location`）的列表中，筛选出其特定字符串属性（如`address.number`）与另一个字符串列表（如`houseNumbers`）中任一元素匹配的对象。教程涵盖了正确的Stream操作、性能考量以及Java面向对象编程的最佳实践。
在Java开发中，我们经常需要处理对象集合，并根据某些条件进行筛选。当条件涉及到将一个复杂对象的某个属性与另一个字符串集合进行匹配时，Stream API提供了一种强大且声明式的方法。本教程将指导您如何高效地实现这一需求，同时遵循Java的编程规范。
首先，我们定义示例中使用的领域模型：Location和Address。为了遵循Java的封装原则，我们将字段设为私有，并通过公共的getter方法提供访问。
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;
}
// 可选：重写equals和hashCode方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GPS gps = (GPS) o;
return Double.compare(gps.latitude, latitude) == 0 &&
Double.compare(gps.longitude, longitude) == 0;
}
@Override
public int hashCode() {
return java.util.Objects.hash(latitude, longitude);
}
}
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 java.util.Objects.equals(street, address.street) &&
java.util.Objects.equals(number, address.number);
}
@Override
public int hashCode() {
return java.util.Objects.hash(street, number);
}
}
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;
}
// 可选：重写equals和hashCode方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Location location = (Location) o;
return java.util.Objects.equals(gps, location.gps) &&
java.util.Objects.equals(address, location.address);
}
@Override
public int hashCode() {
return java.util.Objects.hash(gps, address);
}
}假设我们有一个List<Location>，以及一个List<String>表示我们感兴趣的门牌号（houseNumbers）。我们的目标是筛选出所有Location对象，其address.number属性存在于houseNumbers列表中。
立即学习“Java免费学习笔记（深入）”；
一个常见的初学者尝试是使用嵌套的anyMatch，但这通常会导致编译错误或效率低下：
// 这是一个错误的尝试，会导致编译错误 // List<Location> filteredLocations = locations.stream() // .anyMatch(location -> // houseNumbers.stream().anyMatch(location.getAddress().getNumber()) // );
上述代码会产生编译错误，因为它期望anyMatch的参数是一个Predicate，而不是一个字符串。即使修正为正确的Lambda表达式，如houseNumbers.stream().anyMatch(hn -> hn.equals(location.getAddress().getNumber()))，这种嵌套Stream的方式在性能上也不是最优解，尤其当houseNumbers列表很大时，每次对Location进行匹配都需要遍历houseNumbers，导致整体时间复杂度接近O(N*M)，其中N是locations的大小，M是houseNumbers的大小。
为了提高匹配效率，我们应该将houseNumbers列表转换为HashSet。HashSet提供了平均O(1)的查找时间复杂度，这比List的contains()方法（平均O(N)）效率高得多。
核心思路：
示例代码：
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;
public class LocationFilterExample {
public static void main(String[] args) {
// 示例数据
List<String> houseNumbers = Arrays.asList("101", "205", "303");
List<Location> locations = new ArrayList<>();
locations.add(new Location(new GPS(1.0, 1.0), new Address("Main St", "101")));
locations.add(new Location(new GPS(2.0, 2.0), new Address("Park Ave", "102")));
locations.add(new Location(new GPS(3.0, 3.0), new Address("Elm St", "205")));
locations.add(new Location(new GPS(4.0, 4.0), new Address("Oak St", "301")));
locations.add(new Location(new GPS(5.0, 5.0), new Address("Maple Dr", "303")));
locations.add(new Location(new GPS(6.0, 6.0), new Address("Pine Ln", "404")));
// 1. 将houseNumbers转换为HashSet以优化查找性能
Set<String> targetHouseNumbers = new HashSet<>(houseNumbers);
// 2. 使用Stream API进行筛选
List<Location> filteredLocations = locations.stream()
.filter(location -> targetHouseNumbers.contains(location.getAddress().getNumber()))
.collect(Collectors.toList()); // 对于Java 16+，可以使用 .toList();
// 打印结果
System.out.println("原始门牌号列表: " + houseNumbers);
System.out.println("筛选后的地点:");
filteredLocations.forEach(location ->
System.out.println(" Street: " + location.getAddress().getStreet() +
", Number: " + location.getAddress().getNumber())
);
}
}输出示例：
原始门牌号列表: [101, 205, 303] 筛选后的地点: Street: Main St, Number: 101 Street: Elm St, Number: 205 Street: Maple Dr, Number: 303
List<Location> filteredLocations = locations.stream()
.filter(location -> targetHouseNumbers.contains(location.getAddress().getNumber()))
.toList();通过本教程，我们学习了如何使用Java Stream API高效地从复杂对象列表中筛选出满足特定字符串属性匹配条件的元素。关键在于利用HashSet的O(1)查找特性，将其与Stream.filter()操作结合，从而避免了低效的嵌套循环或List.contains()操作，显著提升了大型数据集处理的性能。同时，遵循Java的封装原则，通过getter方法访问对象属性，是编写健壮、可维护代码的最佳实践。
以上就是使用Java Stream API高效筛选复杂对象列表的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
245
收藏
