本文旨在指导开发者如何通过将嵌套循环转换为HashMap来优化Java代码的性能，特别是当循环中涉及到对象属性的相等性检查时。通过利用HashMap的快速查找特性，可以显著降低时间复杂度，提高代码执行效率。本文将提供详细的步骤和示例代码，帮助你理解和应用这种优化技巧。
在Java开发中，经常会遇到嵌套循环，尤其是在处理对象集合时。当循环内部需要进行对象属性的比较时，时间复杂度会显著增加。使用HashMap可以有效地优化这种情况，将时间复杂度从O(n*m)降低到接近O(n+m)。下面我们将通过一个具体的例子来说明如何实现这种优化。
问题描述
假设有两个Java对象：Object1和Object2。Object1包含字符串属性和一个Object2的列表。我们的目标是遍历两个对象列表，根据Object1和Object2的名称属性是否相等，将匹配的Object2对象添加到Object1的列表中。
立即学习“Java免费学习笔记（深入）”；
import java.util.ArrayList;
import java.util.List;
public class Object1 {
private String name;
private String xyz;
private List<Object2> listObject2;
// Getters and setters
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getXyz() {
return xyz;
}
public void setXyz(String xyz) {
this.xyz = xyz;
}
public List<Object2> getListObject2() {
return listObject2;
}
public void setListObject2(List<Object2> listObject2) {
this.listObject2 = listObject2;
}
}
import java.util.ArrayList;
import java.util.List;
public class Object2 {
private String name;
private String abc;
private String def;
// Getters and setters
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAbc() {
return abc;
}
public void setAbc(String abc) {
this.abc = abc;
}
public String getDef() {
return def;
}
public void setDef(String def) {
this.def = def;
}
}原始实现（嵌套循环）
以下是使用嵌套循环的原始实现：
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void fillNestedObject() {
List<Object1> listObject1 = new ArrayList<>();
listObject1 = fetchObjects1FromApi();
List<Object2> listObject2 = new ArrayList<>();
listObject2 = fetchObjectsFromApi2();
for (Object1 object1 : listObject1) {
List<Object2> tmpList = new ArrayList<>();
for (Object2 object2 : listObject2) {
if (object1.getName().equals(object2.getName())) {
tmpList.add(object2);
}
}
object1.setListObject2(tmpList);
}
}
private static List<Object1> fetchObjects1FromApi() {
// 模拟从API获取Object1列表
List<Object1> list = new ArrayList<>();
Object1 obj1 = new Object1();
obj1.setName("A");
list.add(obj1);
Object1 obj2 = new Object1();
obj2.setName("B");
list.add(obj2);
return list;
}
private static List<Object2> fetchObjectsFromApi2() {
// 模拟从API获取Object2列表
List<Object2> list = new ArrayList<>();
Object2 obj1 = new Object2();
obj1.setName("A");
list.add(obj1);
Object2 obj2 = new Object2();
obj2.setName("B");
list.add(obj2);
Object2 obj3 = new Object2();
obj3.setName("A");
list.add(obj3);
return list;
}
public static void main(String[] args) {
fillNestedObject();
// 在这里可以验证结果
}
}这种实现的时间复杂度为O(n*m)，其中n是listObject1的大小，m是listObject2的大小。
优化实现（使用HashMap）
为了优化性能，我们可以使用HashMap来存储Object2对象，其中键是Object2的名称。这样，我们就可以在O(1)的时间复杂度内查找与Object1名称匹配的Object2对象。
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Main {
public static void fillNestedObject() {
List<Object1> listObject1 = new ArrayList<>();
listObject1 = fetchObjects1FromApi();
List<Object2> listObject2 = new ArrayList<>();
listObject2 = fetchObjectsFromApi2();
// 创建一个HashMap，键为Object2的名称，值为Object2对象列表
Map<String, List<Object2>> object2Map = new HashMap<>();
for (Object2 object2 : listObject2) {
if (!object2Map.containsKey(object2.getName())) {
object2Map.put(object2.getName(), new ArrayList<>());
}
object2Map.get(object2.getName()).add(object2);
}
// 遍历Object1列表，从HashMap中查找匹配的Object2列表
for (Object1 object1 : listObject1) {
object1.setListObject2(object2Map.getOrDefault(object1.getName(), new ArrayList<>()));
}
}
private static List<Object1> fetchObjects1FromApi() {
// 模拟从API获取Object1列表
List<Object1> list = new ArrayList<>();
Object1 obj1 = new Object1();
obj1.setName("A");
list.add(obj1);
Object1 obj2 = new Object1();
obj2.setName("B");
list.add(obj2);
return list;
}
private static List<Object2> fetchObjectsFromApi2() {
// 模拟从API获取Object2列表
List<Object2> list = new ArrayList<>();
Object2 obj1 = new Object2();
obj1.setName("A");
list.add(obj1);
Object2 obj2 = new Object2();
obj2.setName("B");
list.add(obj2);
Object2 obj3 = new Object2();
obj3.setName("A");
list.add(obj3);
return list;
}
public static void main(String[] args) {
fillNestedObject();
// 在这里可以验证结果
}
}这种实现的时间复杂度主要取决于构建HashMap的时间（O(m)）和遍历listObject1的时间（O(n)），因此总的时间复杂度接近O(n+m)。
使用Java 8 Stream API优化
Java 8 Stream API 提供了一种更简洁的方式来实现相同的逻辑：
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Main {
public static void fillNestedObject() {
List<Object1> listObject1 = new ArrayList<>();
listObject1 = fetchObjects1FromApi();
List<Object2> listObject2 = new ArrayList<>();
listObject2 = fetchObjectsFromApi2();
// 使用Stream API将Object2列表转换为HashMap
Map<String, List<Object2>> object2Map = listObject2.stream()
.collect(Collectors.groupingBy(Object2::getName));
// 遍历Object1列表，从HashMap中查找匹配的Object2列表
listObject1.forEach(object1 -> object1.setListObject2(object2Map.getOrDefault(object1.getName(), new ArrayList<>())));
}
private static List<Object1> fetchObjects1FromApi() {
// 模拟从API获取Object1列表
List<Object1> list = new ArrayList<>();
Object1 obj1 = new Object1();
obj1.setName("A");
list.add(obj1);
Object1 obj2 = new Object1();
obj2.setName("B");
list.add(obj2);
return list;
}
private static List<Object2> fetchObjectsFromApi2() {
// 模拟从API获取Object2列表
List<Object2> list = new ArrayList<>();
Object2 obj1 = new Object2();
obj1.setName("A");
list.add(obj1);
Object2 obj2 = new Object2();
obj2.setName("B");
list.add(obj2);
Object2 obj3 = new Object2();
obj3.setName("A");
list.add(obj3);
return list;
}
public static void main(String[] args) {
fillNestedObject();
// 在这里可以验证结果
}
}这段代码使用了Collectors.groupingBy()方法，它将Object2列表转换为一个HashMap，其中键是Object2的名称，值是具有相同名称的Object2对象列表。
注意事项
- 确保Object1和Object2的getName()方法正确实现，并且返回的名称具有唯一性。
- 如果Object2列表非常大，可以考虑使用并发HashMap来进一步提高性能。
- 在实际应用中，需要根据具体情况选择合适的优化方法。如果列表的大小非常小，那么使用HashMap可能不会带来明显的性能提升，反而会增加代码的复杂性。
总结
通过将嵌套循环转换为HashMap，我们可以显著降低时间复杂度，提高代码的执行效率。这种优化技巧在处理大型对象集合时尤其有效。使用Java 8 Stream API可以进一步简化代码，使其更具可读性和可维护性。在实际开发中，应该根据具体情况选择合适的优化方法，并进行性能测试，以确保优化能够带来实际的性能提升。
