使用递归比较两个数组的值？

Question

我正在尝试检查两个数组是否具有相同的长度，以及相同的位置是否具有相同的值。

我当前的代码如下所示：

     public class MyArray {
private int size;
private int[] array;
private boolean isSorted; //to check if array is sorted
private static int arrCount; //used to identify which MyArray object

public MyArray(){
    size = 10;
    array = new int[10];
    arrCount+=1;

}
public MyArray(int Size){
    size = Size;
    array = new int[Size];
    arrCount+=1;

}
public MyArray(MyArray arrOther){
    this.size = arrOther.getSize();
    this.array = arrOther.getArray();

    arrCount+=1;
}
public int getSize(){
    return size;
}
public int[] getArray(){
    return array;
}
@Override
public boolean equals(Object other){
    if (other instanceof MyArray){
        MyArray second = (MyArray) other;
        if (second.getSize() == this.getSize())
        return equalsHelper(this.getArray(), second.getArray(), 0, (size-1));
    }
    //else
    return false;
}
private boolean equalsHelper(int[] first, int[] second, int iStart, int iEnd) {
if (iStart == iEnd) {
    return true;
}

if (first[iStart] == second[iStart]) {
    if (equalsHelper(first, second, (iStart + 1), iEnd)) {
        return true;
    }
}
return false;
}
}//end class

由于某种原因，即使数组的顺序不同，它也总是返回 true。

这里在主程序中调用了equals方法：

  --main method--
 if (MA2.equals(MA1)) //the arrays are identical here
 {
     System.out.println("The first and second arrays are equal.");
 }
 else {System.out.println("The first and second arrays are NOT equal.");}

 MA2.sort(); //the order of the elements changes
 System.out.println("The second array has been sorted in ascending order.");

  if (MA2.equals(MA1))
 {
     System.out.println("The first and second arrays are equal.");
 }
 else {System.out.println("The first and second arrays are NOT equal.");}

Answer 1

首先检查（最好）在你的助手之外应该看看两个数组是否有相等的长度。否则就没有意义了。

equalsHelper 应该在到达数组末尾时返回 true。

我认为没有理由为索引设置 2 个单独的指针，因为数组需要具有相同的大小并且正在检查相同的索引。

调用：

....
....
if(first.length != second.length)
    return false;
return equalsHelper(first, second, 0);

辅助方法...

private boolean equalsHelper(int[] first, int[] second, int indx) {
    if(indx == first.length)
        return true;
    if(first[indx] != second[indx)
        return false;
    return equalsHelper(first, second, indx+1);
}

Answer 2

首先，iStart 和 iEnd 是多余的。使用 .length

String[] array = new String[10];
int size = array.length;

如果您尝试比较可能相同的数组内容，则需要手动传递。

    for(int i = 0: (i > first.length || i > second.length; i++){
        if(first[i] != second[i]){
            return false;
        }
    }
    return true

你的下一个问题是

 if (iStart == iEnd){
            return first[iEnd] == second[iEnd]; //return true or false

你这里的逻辑是错误的。你不能像这样直接比较数组。它正在比较内存地址。除非您在调用该方法时通过完全相同的数组，否则这将始终是错误的——我认为这不是您想要做的

数组长度是手动设置的，因此需要有意识地尝试有所不同。

如果您期望不同的长度，我建议您使用 ArrayList。它们也更灵活。

ArrayList <Integer> a = new ArrayList <int>();

ArrayList <Integer> b = new ArrayList <int>();

然后你需要检查它们的长度。 ArrayList 使用 .length() 方法而不是 Array[].length 属性

if(a.length() == b.length()){

那么如果要查看每个索引中的每个值是否相同，则需要如上所示手动传递数组。