Question

我坚持一个特定的逻辑。我有两个数组，我需要检查这两个数组的值是否相等且顺序相同。循环也是允许的。让我们说：

Fragment

数组值允许重复。我不能对数组进行排序，因为允许重复数据，它会搞乱数组顺序。

Answer 1

试试这个：

<强>代码：

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 2

你可以写你的嵌套循环，但让我们想一点不同。如果我们将第二个数组追加到自身，我们就可以做一个＆＃34; indexOf＆＃34;在第二个数组上操作第一个数组。这里有一些未经测试的代码显示了这个想法：

Alamofire.request("https://serviceURL.de", method: .post, parameters: parameters, encoding: JSONEncoding.default, headers: nil).responseJSON { (response:DataResponse<Any>) in

        if let headerFieldValue =  response.response?.allHeaderFields["YOUR_HEADER_FIELD"] as? String {

            // do somthing 
        }

}

或更多以列表为中心的方法：

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;
}

你可以循环而不是复制数据，但这是程序员时间与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) {
    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;
}

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。

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

3 个答案: