Java 查找向量的重复项并删除，保留平行向量的顺序

这段代码只是一个测试，用于查找一个向量的副本并将其删除，同时删除其他两个向量的对应编码对象

这将在第3行中提供一个Arrayoutofindex作为输出。您有什么建议吗

        for (int k = 0 ; k < vA.size() ; k++)
            {                       
                Object a = vA.elementAt(0);
                Object b = vA.elementAt(k);
                if(a == b && k!=0)
                {
                int duplicate = vA.indexOf(b);
                vA.removeElementAt(duplicate);
                vB.removeElementAt(duplicate);
                vC.removeElementAt(duplicate);                    
                }

for（int k=0；k

for（int k=0；k根据问题，我建议您阅读，因为它解释了从数组中删除重复项的下注方法

您可以使用以下方法：
RemovedUpplicate方法：

    /** List order not maintained **/
public static void removeDuplicate(ArrayList arlList)
{
 HashSet h = new HashSet(arlList);
 arlList.clear();
 arlList.addAll(h);
}

以及RemovedDuplicateWithOrder方法：

    /** List order maintained **/
public static void removeDuplicateWithOrder(ArrayList arlList)
{
   Set set = new HashSet();
   List newList = new ArrayList();
   for (Iterator iter = arlList.iterator(); iter.hasNext();) {
      Object element = iter.next();
      if (set.add(element))
         newList.add(element);
   }
   arlList.clear();
   arlList.addAll(newList);
}

希望这些能对您有所帮助。
您正在为条件执行vA.size（），然后尝试从vA内部循环中删除元素。这导致了异常

将vA.size存储在单独的变量中

int size = vA.size();
for (int k = 0 ; k <= size ; k++)

相反，这是一个单独的新列表

toBeRemoved.add(b);//b is the element to be removed later

并在循环后从vA中移除所有toBeRemoved

vA.removeAll(toBeRemoved );

编辑：

您的新代码将如下所示-

int vASize = vA.size();
List vAToBeRemoved = new ArrayList();
for (int k = 0 ; k < vASize; k++)
            {                       
                Object a = vA.elementAt(0);
                Object b = vA.elementAt(k);
                if(a == b )
                {
                int duplicate = vA.indexOf(b);
                vAToBeRemoved.add(b);//elements to be removed later.
                vA.removeElementAt(duplicate);
                vB.removeElementAt(duplicate);
                vC.removeElementAt(duplicate);                    
                }
             }
vA.removeAll(vAToBeRemoved);

int vASize=vA.size（）；
List vAToBeRemoved=新建ArrayList（）；
for（int k=0；k
使用下面的方法从向量中删除重复元素

公共静态向量RemovedUpplicateResults（向量结果向量）{

for（int i=0；在开始之前，我会找出vA的大小。正如Vipar所说，每次迭代都会调用vA.size（），排序向量可能会提高性能，但需要计算。我更正了它。这非常好！启发！问题解决了！！；-）1.000.000 thnx！@user1296783我很高兴能帮上忙。那么请接受这个答案：）创建LinkedHashSet将保留秩序，而无需遍历原始ArrayList。
int vASize = vA.size();
List vAToBeRemoved = new ArrayList();
for (int k = 0 ; k < vASize; k++)
            {                       
                Object a = vA.elementAt(0);
                Object b = vA.elementAt(k);
                if(a == b )
                {
                int duplicate = vA.indexOf(b);
                vAToBeRemoved.add(b);//elements to be removed later.
                vA.removeElementAt(duplicate);
                vB.removeElementAt(duplicate);
                vC.removeElementAt(duplicate);                    
                }
             }
vA.removeAll(vAToBeRemoved);

for(int i=0;i<resultsVector.size();i++){        
    for(int j=0;j<resultsVector.size();j++){            
            if(i!=j){                                            
                Object resultsVectorObject1 = resultsVector.elementAt(i);
                Object resultsVectorObject2 = resultsVector.elementAt(j);
                Object[] resultsObjectArray1 = (Object[]) resultsVectorObject1;
                Object[] resultsObjectArray2 = (Object[]) resultsVectorObject2;
                if(Arrays.equals(resultsObjectArray1, resultsObjectArray2))
                {
                    resultsVector.removeElementAt(j);
                }
            }
    }
}
return resultsVector;