Question

以下是当前正常运行的代码

    Set<Employee> employeeSet = inCompanyBean.getEmployees();
    Set<Employee> innerEmployeeSet = employeeSet;

    Iterator<Employee> iter = employeeSet.iterator();
    while (iter.hasNext()) {
         Employee formerEmp = iter.next();
         Iterator<Employee> itLater = innerEmployeeSet.iterator();
         while(itLater.hasNext()){
            Employee laterEmployee = itLater.next();
            // do the processing
         }
     }

    }

基本上想要将每个对象的值与剩余对象进行比较。

实施例，如果有5个Employee对象，则比较如下第一个对象 - 与所有对象值进行比较第二个对象 - 与所有对象值进行比较第三个对象 - 与所有对象值进行比较

上述逻辑工作正常。

但是我想知道实现性能的最佳方法。以上内容占用了大量内存。

感谢。

Answer 1

尝试将set转换为list并根据索引进行迭代：

Set<Employee> empSet= new HashSet<Employee>();
empSet.add(...);
List<Employee> empList= new ArrayList<Employee>(empSet);
for (int i =0;i<empList.size(); i++) {
    for (int j =0;j<empList.size(); j++) {
        if (i==j) {
            continue;
        }
        if (empList.get(i).compareTo(empList.get(j)) > 0) {//do something
        }
    }
}

Answer 2

嵌套循环本身似乎并不是内在的内存饥饿 - 也许它只是未使用的代码消耗内存？

也就是说，为什么不使用现代for语法并使代码更具可读性：

Set<Employee> employeeSet = inCompanyBean.getEmployees();

for (Employee outer : employeeSet) {
    for (Employee inner : employeeSet) {
        if (inner == outer) continue;

        // do the processing
    }
}

或者，如果proc(a, b)给出与proc(b, a)相同的结果而proc(a, a)是无操作，那么只需让内循环从一个循环迭代就可以减少一半的处理操作不仅仅是外循环的当前位置，如果不使用显式索引，这是不可能的：

Set<Employee> employeeSet = inCompanyBean.getEmployees();
Employee[] employees = employeeSet.toArray(new Employee[0]);
int n = employees.length;

for (int i = 0; i < n; ++i) {
    Employee outer = employees[i];
    for (int j = i + 1; j < n; ++j) {   // note start value of 'j'
        Employee inner = employees[j];

        // do the processing
    }
}

在Java中循环迭代第二次Set的最佳方法是什么？

2 个答案: