檢查兩個數組的值是否相等並且順序相同

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。