Java 具有arrylist且大小正在更改的循环的双精度

情况是，我有两个嵌套的for循环，每个循环都在对象的arraylist中迭代。外部for循环获取当前索引处的对象，并将其添加到另一个名为tempCurrEmp的arraylist中。然后假设内部for循环遍历并删除原始arraylist中在特定字段相同的所有对象。问题是它没有删除所有副本，我不知道为什么。我假设这与调用remove后索引的更改有关，但我可以肯定。如有任何建议，我们将不胜感激

for(int i=0;i<tempAllEmp.size();i++){
                tempCurrEmp.add(tempAllEmp.get(i));
                tempEmp = tempAllEmp.get(i);
                Log.d("LOOP", "Curr emp is: " + tempAllEmp.get(i).getEmployee());
                for(int j=i+1;j<tempAllEmp.size();j++){
                    Log.d("LOOP", "Comparing:" + tempEmp.getEmployee() + " and " + tempAllEmp.get(j).getEmployee().trim());
                    if(tempAllEmp.get(j).getEmployee().trim().equals(tempEmp.getEmployee())){
                        Log.d("LOOP", "They were equal");
                        tempCurrEmp.add(tempAllEmp.get(j));
                        tempAllEmp.remove(j);

                    }
                }
                maxPunch.add(getMaxPunch(tempCurrEmp));
                tempCurrEmp.clear();                    
            }

---

for（int i=0；i与
tempAllEmp.get（j）.getEmployee（）.trim（）相比，您是否忘记修剪
tempEmp.getEmployee（）

ArrayList public E remove（int索引）
在指定的位置删除元素
此列表中的位置。将所有后续元素向左移动
（从他们的指数中减去一）

因此，在删除后，必须将1减去j

tempAllEmp.remove(j--);

并修复比较：

if(tempAllEmp.get(j).getEmployee().equals(tempEmp.getEmployee())){

总而言之，您只是将一个列表放到另一个列表中，因为：

//你找到两个相同的雇员

tempCurrEmp.add(tempAllEmp.get(i));
tempEmp = tempAllEmp.get(i);

//然后你试着弄清楚你刚从temAllEmp找到的雇员是否真的存在于tempAllEmp中

for(int j=i+1;j<tempAllEmp.size();j++){
if(tempAllEmp.get(j).getEmployee().trim().equals(tempEmp.getEmployee())){                        tempCurrEmp.add(tempAllEmp.get(j));
tempAllEmp.remove(j);
}

====================================================

试试这个：

List<Employee> currentEmployees = new ArrayList<Employee>();
for(int i=0 ; i <= tempAllEmp.size() ; i++ ){
    if(! currentEmployess.contains(templAllEmp.get(i))){
        currentEmployees.add(templAllEmp.get(i));
    }
}

您必须更改算法并使用
Set
。请参见下面的示例：

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

public class Program {

    public static void main(String args[]) throws IOException {
        List<Node> nodes = new ArrayList<>();
        // generate data
        Random random = new Random();
        while (nodes.size() < 100) {
            Node node = new Node();
            node.employee = String.valueOf(random.nextInt(10) + 1);

            nodes.add(node);
        }
        System.out.println(nodes);

        // remove duplicates
        List<Node> newNodes = getUiniqueCollection(nodes);
        System.out.println(newNodes);
    }

    private static List<Node> getUiniqueCollection(List<Node> nodes) {
        List<Node> resultNodes = new ArrayList<>();
        Set<String> employees = new HashSet<>();
        for (Node node : nodes) {
            String employee = node.employee.trim();
            if (!employees.contains(employee)) {
                employees.add(employee);
                resultNodes.add(node);
            }
        }

        return resultNodes;
    }
}

class Node {

    String employee;

    @Override
    public String toString() {
        return employee;
    }
}

import java.io.IOException；
导入java.util.ArrayList；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Random；
导入java.util.Set；
公共课程{
公共静态void main（字符串args[]）引发IOException{
列表节点=新的ArrayList（）；
//生成数据
随机=新随机（）；
while（nodes.size（）<100）{
节点=新节点（）；
node.employee=String.valueOf（random.nextInt（10）+1）；
nodes.add（node）；
}
System.out.println（节点）；
//删除重复项
List newNodes=getUiniqueCollection（节点）；
System.out.println（newNodes）；
}
私有静态列表getUiniqueCollection（列表节点）{
List resultNodes=new ArrayList（）；
Set employees=new HashSet（）；
用于（节点：节点）{
字符串employee=node.employee.trim（）；
如果（！employee.contains（employee））{
employees.add（employees）；
添加（节点）；
}
}
返回结果节点；
}
}
类节点{
字符串雇员；
@凌驾
公共字符串toString（）{
返回员工；
}
}
您没有修剪tempEmp.getEmployee（）文件同样，您希望在结果列表中有唯一的元素，不是吗？我的意思是，列表中的每个对象都应该有唯一的
employee
属性。如果您发布了一个最低限度的工作示例，我可以复制、粘贴、编译和运行，我很乐意尝试一下。我认为您需要减少
I
（
I--
）每次删除后。请稍等。我假设
size（）
始终是原始长度（这意味着在对for循环的初始调用时仅计算一次）。如果它正确更新（对于循环的其余部分，它的初始值不是硬编码的），那么是的，只有
j
需要递减。抱歉。我很确定，只有j需要在移除后递减，就像Teg回答的那样修剪并不重要，我只是用它来调试，谢谢。好的。你的if语句也使用了修剪过的tempAllEmp.getEmployee（）但是我想这也没关系吧？那不是真的。
j
是基于
I
的。所以递减它只会一直持续到当前迭代结束。然后它又会出错。你需要递减
I
。实际上，
j
和
I
需要递减。在当前迭代之后，我是正确的，数组的大小会因移除而缩短。如果你减少i，你将重新进行当前的子迭代。我已经被教育了。请参阅我在原始帖子下的评论。只有
j
需要减少。实际上这似乎是正确的答案，但我认为其他地方有一个bug。一旦我确定循环是正确的，我将我接受，谢谢！
public boolean equals(Object obj) {
    if (obj == this) {
        return true;
    }
    if (!(obj instanceof Employee)) {
        return false;
    }
    Employee other = (Employee) obj;
    return this.employeeId.equals(other.employeeId);
}

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

public class Program {

    public static void main(String args[]) throws IOException {
        List<Node> nodes = new ArrayList<>();
        // generate data
        Random random = new Random();
        while (nodes.size() < 100) {
            Node node = new Node();
            node.employee = String.valueOf(random.nextInt(10) + 1);

            nodes.add(node);
        }
        System.out.println(nodes);

        // remove duplicates
        List<Node> newNodes = getUiniqueCollection(nodes);
        System.out.println(newNodes);
    }

    private static List<Node> getUiniqueCollection(List<Node> nodes) {
        List<Node> resultNodes = new ArrayList<>();
        Set<String> employees = new HashSet<>();
        for (Node node : nodes) {
            String employee = node.employee.trim();
            if (!employees.contains(employee)) {
                employees.add(employee);
                resultNodes.add(node);
            }
        }

        return resultNodes;
    }
}

class Node {

    String employee;

    @Override
    public String toString() {
        return employee;
    }
}