检查两个数组的值是否相等并且顺序相同

Question

我被困在特定的逻辑中。我有两个数组，我需要检查这两个数组的值是否相等并且顺序相同。循环也是允许的。假设：

array1 = {4, 3, 2, 1} 
array2 = {1, 4, 3, 2} -- true. 

array1 = {4, 3, 2, 1} 
array2 = {2, 1, 4, 3} -- true. 

数组值中允许重复。我无法将数组排序为允许重复的数据，并且会扰乱数组顺序。

Answer 1

你可以写你的嵌套循环，但让我们觉得有点不同。如果我们将第二个数组附加到自身，我们可以在第二个数组上执行第一个数组的“indexOf”操作。这是一个有点未经测试的代码显示的想法：

public static boolean arraysMatch(int[] array1, int[] array2) { 
    int[] combined = new int[array2.length * 2]; 
    System.arraycopy(array2, 0, combined, 0, array2.length); 
    System.arraycopy(array2, 0, combined, array2.length, array2.length); 
    return Collections.indexOfSubList(Arrays.asList(combined), Arrays.asList(array1)) != -1; 
} 

还是比较列表为中心的方法：

public static boolean arraysMatch(int[] array1, int[] array2) { 
    List<Integer> combined = new ArrayList<>(array2.length * 2); 
    List<Integer> array2List = Arrays.asList(array2); 
    combined.addAll(array2List); 
    combined.addAll(array2List); 
    return Collections.indexOfSubList(combined, Arrays.asList(array1)) != -1; 
} 

你可以做循环，而不是周围的复制数据，但它的程序员时间与问题CPU时间。

编辑：我知道答案是可以接受的，但它还没有真正完成。如果允许使用Apache Commons Lang中：https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/ArrayUtils.html

public static boolean arraysMatch(int[] array1, int[] array2) { 
    return Collections.indexOfSubList(
     Arrays.asList(ArrayUtils.toObject(ArrayUtils.addAll(array2, array2))), 
     Arrays.asList(ArrayUtils.toObject(array1)) 
    ) != -1; 
} 

Answer 2

试试这个：

代码：

import java.util.ArrayList; 
import java.util.Arrays; 

public class ArrayComparison { 

    // Create arrays 
    private static int[] array1 = new int[] {2,3,4,7,1}; 
    private static int[] array2 = new int[] {2,3,4,7,1}; 
    private static int[] array3 = new int[] {1,7,4,2,3}; 
    private static int[] array4 = new int[] {1,2,3,4,5,6,7,8,9}; 
    private static int[] array5 = new int[] {2,3,4,5,1}; 

    public static void main(String args[]){ 
     System.out.println(compareArrays(array1, array2)); // True 
     System.out.println(compareArrays(array1, array3)); // True 
     System.out.println(compareArrays(array1, array4)); // False 
     System.out.println(compareArrays(array1, array5)); // False 
    } 

    /** 
    * Compares if a1 is equal than a2, no matter the order 
    * @param a1 Array 1 
    * @param a2 Array 2 
    * @return True if a1 == a2, false if a1 != a2. no matter the order 
    */ 
    private static boolean compareArrays(int[] a1, int[] a2){ 
     boolean areEqual=false; 
     // Clone 
     int[] a1Aux = a1.clone(); 
     int[] a2Aux = a2.clone(); 
     // Sort 
     Arrays.sort(a1Aux); 
     Arrays.sort(a2Aux); 
     // Compare 
     if(a1Aux.length == a2Aux.length){ 
      for(int i=0;i<a1Aux.length;i++){ 
       if(a1Aux[i] != a2Aux[i]){ 
        return areEqual; 
       } 
      } 
      return true; 
     } 
     return areEqual; 
    } 
} 

输出：

true 
true 
false 
false 

Answer 3

这是简单（但非常低效的，涉及到很多复制）。我坚持使用int s的数组（没有列表或其他集合，没有Integer对象）。

public static boolean arraysWrappedEqual(int[] array1, int[] array2) { 
    if (array1.length != array2.length) { 
     return false; 
    } 
    for (int array2startIndex = 0; array2startIndex < array2.length; array2startIndex++) { 
     // compare beginning of array1 with end of array2 and vice versa 
     int[] array1beginning = Arrays.copyOfRange(array1, 0, array1.length - array2startIndex); 
     int[] array1end = Arrays.copyOfRange(array1, array1.length - array2startIndex, array1.length); 
     int[] array2beginning = Arrays.copyOfRange(array2, 0, array2startIndex); 
     int[] array2end = Arrays.copyOfRange(array2, array2startIndex, array2.length); 
     if (Arrays.equals(array1beginning, array2end) && Arrays.equals(array1end, array2beginning)) { 
      return true; 
     } 
    } 
    return false; 
} 

它对于问题中的两种情况都返回true。