如何使用Arrays.equals确定2个2d阵列是否相同（意味着它们具有相同的数字但不是相同的顺序）？在JAVA

Question

这是我到目前为止所获得的代码，但是我的程序说我无法将int []转换为int在第34行（对于（int i：m1）＆＃34;

\n\r

  

我为这个程序使用了2个类。 IdenticalArrays是另一个   class，equals是该类中确定是否的方法   数组彼此相等。现在我的编译器说   它无法找到符号，而且箭头指向的是箭头。在   ＆＃34; IdenticalArrays.equals＆＃34 ;.为什么不明白这是什么   是

public static boolean equals(int [][] m1, int [][] m2)
       {
          boolean val = false;
          int ct = 0;
          for(int i:m1)
          {
             for(int row = 0; row < m1.length; row++)
             {
             for(int column = 0; column < m1[row].length; column++)
             {
                val = false;
                for(int row2 = 0; row2 < m2.length; row2++)
                {
                   for(int column2 = ct; column2 < m2[row2].length; column2++)
                   {
                      if(m2[column2] == row2)
                      {
                         val = true;
                         ct++;
                         break;
                      }
                   }
                }
             }
           }
          }
          return val;      

Answer 1

这应该完全符合你的需要。希望它有所帮助！

public class Program {
static int[][] arr1 = { { 6, 7, 8, 9, 10 }, { 11, 12, 13, 14, 15 } };
static int[][] arr2 = { { 7, 8, 9, 10, 6 }, { 15, 14, 13, 12, 11 } };

public static void main(String[] args) {
    int lowest;
    int switcher;
    int posX = -1;
    int posY = -1;

    for (int i = 0; i < arr2.length; i++) {
        for (int z = 0; z < arr2[i].length; z++) {
            lowest = arr2[i][z];

            for (int x = i; x < arr2.length; x++) {
                if (x == i)
                    for (int y = z; y < arr2[x].length; y++) {
                        if (arr2[x][y] <= lowest) {
                            lowest = arr2[x][y];
                            posX = x;
                            posY = y;
                        }
                    }
                else
                    for (int y = 0; y < arr2[x].length; y++) {
                        if (arr2[x][y] <= lowest) {
                            lowest = arr2[x][y];
                            posX = x;
                            posY = y;
                        }
                    }
                ;
            }
            switcher = arr2[i][z];
            arr2[i][z] = arr2[posX][posY];
            arr2[posX][posY] = switcher;


        }
    }

    System.out.println(equals(arr1, arr2)); 

}

public static boolean equals(int[][] m1, int[][] m2) {
    for (int x = 0; x < m1.length; x++) {
        for (int y = 0; y < m1[x].length; y++) {
            if (m1[x][y] != m2[x][y]) {
                return false;
            }
        }
    }

    return true;
 }
}

Answer 2

您还没有给出相同的＆＃34;明确的定义。让我们一个接一个地从最严格到最宽松的定义：

甲。最严格的表格：

• 当一个数组中的数字是另一个数组的重新排列时，数字数组相同。
• 2D阵列相同当2D阵列中的每个数字阵列可以与另一个2D阵列中的一个相同的 Number阵列配对时，每个2D中的每个数字阵列数组只能与一个Number数组配对。 （即类似于数组数组的定义，一个2D数组是另一个的重排）
• 即。 [ [1,2], [3,4] ]与[ [4,3], [2,1] ]
相同
• [ [1,2], [3,4] ]与[ [1,3], [2,4] ]
不同
• [ [1,1], [2,3] ]与[ [1,2], [2,3] ]
不同

这可以通过

轻松完成

1. 将每个数字数组转换为Map<Integer, Integer>，存储每个数字的计数（让我们称之为规范化数字数组）
2. 将每个2D数组转换为Map< Map<Integer,Integer>, Integer>，存储每个规范化数字数组的计数
3. 只需使用equals来比较两个标准化2D阵列。

B中。宽松形式：

• 如果其中的数字是另一个的重新排列，则两个2D数组彼此相同。
• 即。 [ [1,2], [3,4] ]与[ [1,3], [2,4] ]
相同
• [ [1,1], [2,3] ]与[ [1,2], [2,3] ]
不同

可以通过

轻松完成
• 将2D数组转换为存储每个数字
的Map<Integer, Integer>
• 只需按Map<Integer,Integer>
比较两个equals()即可

℃。最松散的形式：

• 只要二维数组包含相同的数字组
，它们就是相同的
• 即。 [ [1,1], [2,3] ]与[ [1,2], [2,3] ]
相同

它甚至可以更容易：

1. 将2D数组转换为存储数字<{li>的Set<Integer>
2. 通过Set<Integer>
比较2 equals() s

以下是最松散形式的伪代码：

static Set<Integer> toIntegerSet(int[][] intArray) {
    Set<Integer> intSet = new HashSet<Integer>();
    for (int[] a : intArray) {
        for (int i : a) {
            intSet.add(i);
        }
    }
}

static boolean isIdentical(int[][] a1, int[][] a2) {
    return toIntegerSet(a1).equals(toIntegerSet(a2));
}

你的编译器抱怨的原因是你甚至没有正确的语法：

if(IdenticalArrays.equals == true)

应该是

if(IdenticalArrays.equals(array1, array2) == true)

甚至更好，简单

if(IdenticalArrays.equals(array1, array2))

Answer 3

    // the arrays
    int a1[] = {1, 2, 3};
    int a2[] = {2, 3, 1};

    // copy array to don't modify originals
    int[] a1Temp = Arrays.copyOf(a1, a2.length);
    int[] a2Temp = Arrays.copyOf(a2, a2.length);

    // sort the temp arrays
    Arrays.sort(a1Temp);
    Arrays.sort(a2Temp);

    // check if temp arrays are equals
    boolean test = Arrays.equals(a1Temp, a2Temp);
    System.out.println(test);

    // to large arrays, these operations have a coast 2xO(n log n)+3xn