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

//= require node_modules/angular2/bundles/angular2-polyfills
//= require node_modules/systemjs/dist/system.src
//= require node_modules/rxjs/bundles/Rx
//= require node_modules/angular2/bundles/angular2.dev
//= require_tree ./app

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

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

你的逻辑错了。您不能直接比较这样的数组。它正在比较内存地址。这将永远是假的，除非你在调用方法时通过完全相同的数组 - 我不认为你正在尝试做什么

数组长度是手动设置的，因此有意识地努力改变它。

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

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

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

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

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

然后，如果你想看看每个索引中的每个值是否相同，你需要手动传递数组，如上所示。

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

2 个答案: