Question

我知道很多时候才会在stackoverflow中询问这类问题。但我的问题有点不同，我找不到任何类似的情况，所以在这里发布这个问题

问题：我需要从ArrayList中删除重复的对象。我的arrayList的结构如下所示

dataList.add(new ObjectClass("a","b"));
dataList.add(new ObjectClass("c","n"));
dataList.add(new ObjectClass("b","a")); // should be counted as duplicate
dataList.add(new ObjectClass("z","x"));

我需要从上面的列表中删除对象，例如，它会处理＆＃34; a，b＆＃34;和＆＃34; b，a＆＃34;作为重复并删除任何重复的

我的解决方案：步骤1）覆盖DataClass类中的equals方法

class DataClass {
      String source;
      String destination;

      DataClass(String src, String dest) {
        this.source = src;
        this.destination = dest;
      }

      // getter setter for source and destination variables

    @Override
    public boolean equals(Object obj) {
        System.out.println("inside equals");
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ObjectClass other = (ObjectClass) obj;
        if(i.equals(other.getJ())
            && j.equals(other.getI())) {
            return true;
        } else return false;
    }

步骤2）删除重复的方法

public List<DataClass> removeDuplicates(List<DataClass> dataList) {
            List<DataClass> resultList = new ArrayList<DataClass>();

            // Convert array list to Linked list
            LinkedList<DataClass> linkedList = new LinkedList<DataClass>();
            for(DataClass obj: dataList) {
                linkedList.add(obj);
            }

            // Iterate through linked list and remove if values are duplicates
            for(int i = 0; i<linkedList.size();i++) {
              for(int j = i+1;j<linkedList.size();j++) {
                if(linkedList.get(j).equals(linkedList.get(i))) {
                    linkedList.remove();
                }
              }
            }
            resultList.addAll(linkedList);
            return resultList;
        }

我仍在寻找任何更好的优化解决方案，如果有的话。提前致谢

使用解决方案更新 ：我的equals方法需要纠正一些比较逻辑。所以这里是我更新的ObjectClass而不是DataClass，包括正确的重写equals方法

public class ObjectClass {
    String i;
    String j;
    public  ObjectClass(String i, String j) {
        this.i = i;
        this.j = j;
    }
    // getters setters
    // override hashcode

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ObjectClass other = (ObjectClass) obj;

        if((i.equals(other.getJ()) || i.equals(other.getI()))
            && (j.equals(other.getI()) || j.equals(other.getJ()))) {
            return true;
        } else return false;
    }   
}

2）在修复了equals方法之后，我尝试使用removeDuplicate方法中的实现，正如Janos所提到的那样，它正如预期的那样正常工作

    for(ObjectClass obj: dataList) {
        if(!resultList.contains(obj))
            resultList.add(obj);
    }

非常感谢

Answer 1

这里有几个问题：

class DataClass {
      String source;
      String destination;

      // ...

    @Override
    public boolean equals(Object obj) {
        // ...
        ObjectClass other = (ObjectClass) obj;
        if(i.equals(other.getJ())
            && j.equals(other.getI())) {
            return true;
        } else return false;
    }

equals方法将另一个对象强制转换为ObjectClass。它应该转换为定义此方法的同一个类：DataClass。

equals方法会比较i和j个变量，但它们并没有在课堂上的任何地方定义。有source和destination。

当equals与this.i相同且other.j与this.j相同时，other.i方法将返回true，否则返回false。换句话说，(a, b)将等于(b, a)。但它不会与自己相等。这很奇怪，可能不是你想要的。

removeDuplicates方法过于复杂。例如，将数组列表转换为链表是不必要的。这是一个更简单的算法：

对于源列表中的每个值
- 如果结果列表中不存在该值，请将其添加到结果列表

就是这样。

List<DataClass> result = new ArrayList<>();

for (DataClass item : dataList) {
    if (!result.contains(item)) {
        result.add(item);
    }
}
return result;

这假定equals方法的实现是固定的。否则，result.contains步骤将无法正常工作。

另请注意result.contains执行线性搜索：它会检查每个项目，直到找到匹配项。您可以使用集合来提高性能。

Answer 2

使用您的代码

    linkedList.remove();

每次从linkedList删除项目时，所有后续项目的索引都会递减。这会弄乱你的迭代循环。

Answer 3

示例：

DataClass dc = new DataClass("a","b");
List<DataClass> resultList = new ArrayList<DataClass>();
resultList .add(dc);

for (int i=0; i < resultList.size(); i++) {
 if(resultList.get(i).source.equals(dc.source) && resultList.get(i).destination.equals(dc.destination) || resultList.get(i).source.equals(dc.destination) && resultList.get(i).destination.equals(dc.source)) {
    resultList.remove(i);
 }
}

Answer 4

对HashSet和equals使用hashCode，以便区分订单。

class DataClass {
  String source;
  String destination;
  private final Set<String> content = new HashSet< String >();

  DataClass(String src, String dest) {
    this.source = src;
    this.destination = dest;
    content.add(src);
    content.add(dest);
  }

  // getter setter for source and destination variables

@Override
public boolean equals(Object obj) {
    System.out.println("inside equals");
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (!DataClass.class.equals(obj.getClass()))
        return false;
    DataClass other = (DataClass) obj;
    return content.equals(other.content);
}

public int hashCode() {
    return content.hashCode();
}

如需进一步了解如何实施equals和hashCode，您可能需要阅读https://www.mkyong.com/java/java-how-to-overrides-equals-and-hashcode/

使用LinkedHashSet查找重复项：

public List<DataClass> removeDuplicates(List<DataClass> dataList) {
    return new ArrayList<DataClass>(new LinkedHashSet<DataClass>(dataList));
}

为什么我们使用LinkedHashSet代替HashSet？ LinkedHashSet保留了排序，HashSet没有。引自LinkedHashSet javadoc：

这个实现与HashSet的不同之处在于它维护了一个贯穿其所有条目的双向链表。这有联系 list定义迭代排序，即顺序元素被插入到集合中（插入顺序）。

从Java中的List中删除重复的对象

4 个答案: