将嵌套循环中的Java对象数组转换为HashMap以优化性能

本文旨在指导开发者如何通过将嵌套循环转换为HashMap来优化Java代码的性能，特别是当循环中涉及到对象属性的相等性检查时。通过利用HashMap的快速查找特性，可以显著降低时间复杂度，提高代码执行效率。本文将提供详细的步骤和示例代码，帮助你理解和应用这种优化技巧。

在Java开发中，经常会遇到嵌套循环，尤其是在处理对象集合时。当循环内部需要进行对象属性的比较时，时间复杂度会显著增加。使用HashMap可以有效地优化这种情况，将时间复杂度从O(n*m)降低到接近O(n+m)。下面我们将通过一个具体的例子来说明如何实现这种优化。

问题描述

假设有两个Java对象：Object1和Object2。Object1包含字符串属性和一个Object2的列表。我们的目标是遍历两个对象列表，根据Object1和Object2的名称属性是否相等，将匹配的Object2对象添加到Object1的列表中。

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

public class Object1 {

    private String name;
    private String xyz;
    private List 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 getListObject2() {
        return listObject2;
    }

    public void setListObject2(List 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 listObject1 = new ArrayList<>();
        listObject1 = fetchObjects1FromApi();

        List listObject2 = new ArrayList<>();
        listObject2 = fetchObjectsFromApi2();

        for (Object1 object1 : listObject1) {
            List tmpList = new ArrayList<>();
            for (Object2 object2 : listObject2) {
                if (object1.getName().equals(object2.getName())) {
                    tmpList.add(object2);
                }
            }
            object1.setListObject2(tmpList);
        }
    }

    private static List fetchObjects1FromApi() {
        // 模拟从API获取Object1列表
        List 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 fetchObjectsFromApi2() {
        // 模拟从API获取Object2列表
        List 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 listObject1 = new ArrayList<>();
        listObject1 = fetchObjects1FromApi();

        List listObject2 = new ArrayList<>();
        listObject2 = fetchObjectsFromApi2();

        // 创建一个HashMap，键为Object2的名称，值为Object2对象列表
        Map> 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 fetchObjects1FromApi() {
        // 模拟从API获取Object1列表
        List 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 fetchObjectsFromApi2() {
        // 模拟从API获取Object2列表
        List 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 listObject1 = new ArrayList<>();
        listObject1 = fetchObjects1FromApi();

        List listObject2 = new ArrayList<>();
        listObject2 = fetchObjectsFromApi2();

        // 使用Stream API将Object2列表转换为HashMap
        Map> 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 fetchObjects1FromApi() {
        // 模拟从API获取Object1列表
        List 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 fetchObjectsFromApi2() {
        // 模拟从API获取Object2列表
        List 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可以进一步简化代码，使其更具可读性和可维护性。在实际开发中，应该根据具体情况选择合适的优化方法，并进行性能测试，以确保优化能够带来实际的性能提升。