Java 比较两个数组列表对象时出现问题

这似乎是一个愚蠢的问题，但我已经在这个问题上停留了一段时间。我的代码应该检查两个数组列表是否相等，即使它们的顺序不正确。 如果给定对象是包含与线段相同线段的LineSegmentDB，则boolean equals（Object other）返回true。到目前为止，我有以下代码：

public boolean equals(Object other)
    {
//      Object lineSegments2 = new ArrayList<Object>();
//      lineSegments2 = other;

        if (!(other instanceof LineSegmentDB)) {
            return false;
        }
        ArrayList otherTest = (ArrayList) other;


        if(other.size() != lineSegments.size()){
            return false;
        }

        for(int i = 0; i < lineSegments.size(); i++){
            if(!(other.contains(lineSegments.get(i)))){
                return false;
            }
        }

        return true;
        //return lineSegments2;

    }

公共布尔等于（对象其他）
{
//Object lineSegments2=新建ArrayList（）；
//lineSegments2=其他；
如果（！（LineSegmentDB的其他实例））{
返回false；
}
ArrayList otherTest=（ArrayList）other；
如果（其他.size（）！=线段.size（））{
返回false；
}
对于（int i=0；i

我确保other是LineSegmentDB的一个实例。然后我非常确定我必须为other创建一个实例变量，这样我就可以使用other.size（）或other.get（I）之类的东西。我原以为这段代码会和我写的其他代码类似，但不管我怎么做都不管用，有什么建议吗

其他代码：

ArrayList<LineSegment> union(LineSegmentDB other){
        ArrayList<LineSegment> lineSegments2 = new ArrayList<LineSegment>();
        lineSegments2 = other.lineSegments;


        for(int i = 0; i < other.size(); i++){
            if(hasPoint(other.getSegment(i))){
                System.out.println("Has Duplicate");
            }else{
                lineSegments.add(other.getSegment(i));
            }
        }
        return lineSegments;


    }

ArrayList联合（LineSegmentDB其他）{
ArrayList lineSegments2=新的ArrayList（）；
lineSegments2=其他。线段；
对于（int i=0；i

谢谢你的帮助

编辑，不确定这是否有帮助：

public class LineSegmentDB {
    public ArrayList<LineSegment> lineSegments = new ArrayList<LineSegment>();

    LineSegmentDB(){

    }

    public static void main(String[] args) {

        LineSegmentDB db = new LineSegmentDB();
        LineSegmentDB db2 = new LineSegmentDB();

        db.addLineSegment(new LineSegment(2,2,4,2));
        db.addLineSegment(new LineSegment(3,3,1,3));
        db.addLineSegment(new LineSegment(4,2,4,10));
        db2.addLineSegment(new LineSegment(4,2,2,2));
        db2.addLineSegment(new LineSegment(4,2,4,10));
        db2.addLineSegment(new LineSegment(3,3,3,1));
        System.out.println(db.equals(db2));


    }

公共类LineSegmentDB{
公共ArrayList线段=新建ArrayList（）；
LineSegmentDB（）{
}
公共静态void main（字符串[]args）{
LineSegmentDB=新的LineSegmentDB（）；
LineSegmentDB db2=新的LineSegmentDB（）；
db.添加线段（新线段（2,2,4,2））；
db.添加线段（新线段（3,3,1,3））；
db.添加线段（新线段（4,2,4,10））；
addLineSegment（新的线段（4,2,2,2））；
addLineSegment（新的LineSegment（4,2,4,10））；
addLineSegment（新的LineSegment（3,3,3,1））；
System.out.println（db.equals（db2））；
}

我也知道粘贴大量代码是不酷的，但也许它可以回答一些我不能回答的问题。

---

再次感谢，你们真的是救命恩人。

什么是

LineSegmentDB

？它是扩展了一些

列表

实现还是实现了

列表

接口本身？我想答案是否

现在转到您的

equals（）

方法：

if (!(other instanceof LineSegmentDB)) {
    return false;
}

这部分没有问题。您首先正确地检查给定对象是否与实例的类型相同

ArrayList otherTest = (ArrayList) other;
if(other.size() != lineSegments.size()){
    return false;
}

我猜您的

LineSegmentDB

根本不是一个

列表

。您的类必须实现

列表

接口。这可以通过两种方式实现：

• 自行实现接口-

  实现列表

• 扩展已实现接口的类-

  扩展ArrayList

如果上面的一个项目符号为true，则可以安全地将对象投射到

列表中

，然后使用

size（）

或

contains（）

方法

---

希望这有帮助：）

与其说是答案，不如说是猜测，但是

在第一段代码中，检查

other

是否为

LineSegmentDb

类型，如果为真，则将

other

转换为键入

ArrayList

。您将得到一个

java.lang.ClassCastException

，因为正如您所检查的，other是

LineSegmentDb

类型。 在这一行的第二段代码中，

other.lineSegments

让我猜

LineSegmentDb

对象有一个

List

属性。如果是这样，请尝试更改

if(other.lineSegments.size() != lineSegments.size()){
    return false;
}

for(int i = 0; i < lineSegments.size(); i++){
    if(!(other.contains(lineSegments.get(i)))){
        return false;
    }
}

if（其他.lineSegments.size（）！=lineSegments.size（））{
返回false；
}
对于（int i=0；i

到

if（（（LineSegmentDB）other）.lineSegments.size（）！=lineSegments.size（））{
返回false；
}
对于（int i=0；i

---

希望有帮助。

如果不使用任何其他数据结构，则使用列表检查集合相等性可能效率低下

如果您有两个列表，

listA

和

listB

，检查它们是否具有相同元素的直观方法是对

listB

中的每个元素在

listA

中迭代未标记的项。如果它们具有相同的长度，

n

，则这是一个二次时间复杂度

相反，您可以在Java中使用

HashMap

// do proper null and size equality checks
Map<V, Integer> map = new HashMap<V, Integer>();
for (V v : listA) {
    int countSoFar = map.getOrDefault(v, 0);
    map.put(v, countSoFar + 1);
}

for (V v : listB) {
    int countSoFar = map.getOrDefault(v, 0);
    if (countSoFar == 0) {
        return false;
    }
    map.put(v, countSoFar - 1);
}

return checkIfAllValuesInMapEqualZero(map);

//执行正确的空值和大小相等检查
Map Map=newhashmap（）；
对于（V:listA）{
int countSoFar=map.getOrDefault（v，0）；
地图放置（v，countSoFar+1）；
}
对于（V:listB）{
int countSoFar=map.getOrDefault（v，0）；
如果（countSoFar==0）{
返回false；
}
地图放置（v，countSoFar-1）；
}
返回checkIfAllValuesInMapEqualZero（map）；

这实际上是做什么的？它通过增加每个元素的计数器来注册第一个列表中每个元素的出现。然后，它减少第二个列表中每个元素的计数器

如果

listB

中的1类元素比

listA

中的多，则该特定元素的计数器将在您在

listB

中全部使用之前达到0，这表示

listA

中缺少某些元素，这表示它们不相同。
以类似的方式，

listA<
// do proper null and size equality checks
Map<V, Integer> map = new HashMap<V, Integer>();
for (V v : listA) {
    int countSoFar = map.getOrDefault(v, 0);
    map.put(v, countSoFar + 1);
}

for (V v : listB) {
    int countSoFar = map.getOrDefault(v, 0);
    if (countSoFar == 0) {
        return false;
    }
    map.put(v, countSoFar - 1);
}

return checkIfAllValuesInMapEqualZero(map);