Question

除了彼此相邻的重复之外，我能够删除大部分重复项。我不知道我做错了什么。现在我已经嵌套了for循环，将int与ArrayList中的其余部分进行比较。除了我如何设置或增加我跳过副本旁边我开始第一个循环再次循环。我发现删除索引j后重置i = 0很有用。如果副本彼此相邻，它仍然不会删除副本。

for(int i=0;i<original.size();i++){
    for(int j=i+1;j<original.size();j++){
        if(original.get(i)==original.get(j)){
            original.remove(j);   
        }
    }
}

编辑：我发现了我的解决方案，当我将第二个for循环更改为while循环，然后每次都增加，但是当我发现重复时，我从j中删除了1。这样我就会重新开始。

谢谢大家。

Answer 1

注意：

1）你从Arraylist中删除，其大小减少，指数将减少 !!!

<强>实施例

如果原始的arraylist是：{a，b，c，d}，索引i = 2（c）; 如果你删除原文（2）（=====从原文中删除c）索引将是i ++引用原文（3）它不存在!!!!

2）你的对象的类型是什么？如果它们是一个字符串，那么你将使用 .equal（）

Answer 2

使用equals代替==。更改if语句如下：

 original.get(i).equals(original.get(j))

Answer 3

您应该使用迭代器删除列表中的元素，而不是使用List本身。

Answer 4

使用obj.equals（obj other）函数来比较字符串或对象，而不是==运算符。

  for(int i=0;i<original.size();i++){
  for(int j=i+1;j<original.size();j++){
      if(original.get(i).equals(original.get(j))){
          original.remove(j);
      }
  }
  }

如果要根据该对象的某个值删除对象，则需要覆盖bean类的equals方法。请查看java中的equals方法。如果你重写bean类，则不需要两个for循环来删除重复项。将对象添加到数组列表时可以避免重复。

Answer 5

不确定为什么您不想使用HashSet，因为您需要使用.equals()代替==，因为您正在查看值，而不是参考。此外，如果您正在使用循环并从列表中删除元素，则不希望增加j，因为这会跳过一个元素，这显然是您不想这样做的。

Answer 6

无论何时通过索引在List上循环并删除，都必须“向后”循环。让j循环向后。否则你最终会跳过条目。正如@BinaryMan所说。

e.g。（注意，也使用equals（）而不是==）

for(int i=original.size()-1;i>=0;i--){
    for(int j=original.size()-1;j>i;j--){
        if(original.get(i).equals(original.get(j))){
            original.remove(j);   
        }
    }
}

Answer 7

假设列表如下所示：[a,a,a,b,c,a]

这就是迭代的样子（视图是在迭代完成，删除或不删除之后）：

i=0, size = 6 , j=1, arr[i] = a, arr[j] = a, view: [a,a,b,c,a]; (arr[i]==arr[j], will delete)
i=0, size = 5,  j=2, arr[i] = a, arr[j] = b, view: [a,a,b,c,a]; (arr[i]!=arr[j])
i=0, size = 5,  j=3, arr[i] = a, arr[j] = c, view: [a,a,b,c,a]; (arr[i]!=arr[j])
i=0, size = 5,  j=4, arr[i] = a, arr[j] = a, view: [a,a,b,c];   (arr[i]==arr[j], will delete)
i=1, size = 4,  j=2, arr[i] = a, arr[j] = b, view: [a,a,b,c];   (arr[i]!=arr[j])
i=1, size = 4,  j=3, arr[i] = a, arr[j] = c, view: [a,a,b,c];   (arr[i]!=arr[j])
i=2, size = 4,  j=3, arr[i] = b, arr[j] = c, view: [a,a,b,c];   (arr[i]!=arr[j])
i=3, size = 4, .......

邻居不会删除因为j = i + 1，它永远不会有机会相互检查，因为一旦删除一个元素，数组就会向下移动一个索引，所以在下一次迭代时你要去的项目由于j=i+1

，实际上已跳过检查

Answer 8

如果数组元素是整数，那么首先对数组进行排序会更有效率

    Collections.sort(list);
    Iterator<Integer> i = list.iterator();
    int prev = i.next();
    while (i.hasNext()) {
        int next = i.next();
        if (next == prev) {
            i.remove();
        } else {
            prev = next;
        }
    }

请注意，original.get(i)==original.get(j) for Integers不会比较值，即new Integer(1000) == new Integer(1000)生成false

Answer 9

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

public class RemDupFromList {

    public static void main(String[] args)
    {
        List li = new ArrayList();

              li.add("one");
              li.add("two");
              li.add("three");
              li.add("one");//Duplicate
              li.add("one");//Duplicate

             // We have facility to pass a List into Set constructor and vice verse to cast      

                List li2 = new ArrayList(new HashSet(li)); //no order

             // List li2 = new ArrayList(new LinkedHashSet(li)); //If you need to preserve the order use 'LinkedHashSet'

             Iterator it= li2.iterator();
             while(it.hasNext())
             {
                 System.out.println(it.next());
             }

    }
}

Answer 10

ArrayList<String> wordDulicate = new ArrayList<String>();
ArrayList<String> tempList= new ArrayList<String>();

    wordDulicate.add("7");
    wordDulicate.add("7");
    wordDulicate.add("7");

    for (String dupWord : wordDulicate)
    {
      if (!tempList.contains(dupWord)) 
      {
        System.out.println(dupWord);
        tempList.add(dupWord);
      }
    }

在templist中，您将不会重复输入。

删除没有Hashset的ArrayList中的重复项

10 个答案: