如何检查一个数组中的所有元素是否存在于另一个数组中。 但是以相同的顺序

Question

I've been trying to solve the issue of searching through array1 to return a boolean if the elements of array1 can be found in array2. However, it can only be true if array2 contains array1 elements in the same order .

For example, array1 = {3,4,5,6} and array2 = {3, 4, 1, 2, 7, 5, 6} would be true since all elements are found in the same order.

Here's my code so far:

int size = Queue1.size();

for(int i = 0; i < size; i++) {
    arr3[i] = Queue1.dequeue();
}

boolean test = Arrays.asList(arr2).containsAll(Arrays.asList(arr3));
System.out.println(test);

The variable test returns to be false for the input of

• arr3 = {3,4,5,6}
• arr2 = {3,4,2,1,5,10,9,8,6,7}

Answer 1

This is a simple algorithm to resolve your problem, base on List<Integer> contains and indexOf functions:

code (with comments) :

public static void main(String[] args) {

    Integer[] array1 = new Integer[]{3,4,5,6};
    Integer[] array2 = new Integer[]{3, 4, 1, 2, 7, 5, 6};
    
    List<Integer> list1 =  Arrays.asList(array1);
    List<Integer> list2 =  Arrays.asList(array2);
    
    boolean check = false;
    int i = 0;
    for (Integer n : list1) {
        if (i == 0) {
            if (list2.contains(n)) {// first element check if it's on the second array
                check = true;
            }else check = false;
        }else {
            // check if the element in the array2 and its index is > of the previous element
            if (list2.contains(n) && list2.indexOf(n) > list2.indexOf(list1.get(i-1))) {
                check = true;
            }else {
                check = false;
                break;
                
            }
        }
        i++;
    }
    System.out.println(check);
}

result:

input 1:

Integer[] array1 = new Integer[]{3,4,5,6};
Integer[] array2 = new Integer[]{3, 4, 1, 2, 7, 5, 6};

output 1: true

input 2:

Integer[] array1 = new Integer[]{3,7,4,6};
Integer[] array2 = new Integer[]{3, 4, 1, 2, 7, 5, 6};

output 2: false

Answer 2

You are using the right approach, there's a suttle thing that you have to pay attention when using Arrays.asList , look:

If you pass an array of int[] to asList() it will return a List<int[]> rather than a List of Integer .

But if you pass an array of Integer[] to asList() it will return a List of Integer and you will be able to compare it.

See if on code it is more clear:

    public static void main(String[] args) {
    Integer[] arr1 = {1, 2, 3, 4};
    Integer[] arr2 = {1, 2, 3, 4, 5};
    boolean wrappers = checkWrappers(arr2, arr1);
    System.out.println(wrappers); // true

    int[] err1 = {1, 2, 3, 4};
    int[] err2 = {1, 2, 3, 4, 5};
    boolean primitives = checkPrimitives(err2, err1);
    System.out.println(primitives); // false
}

public static boolean checkWrappers(Integer[] outer, Integer[] inner) {
    List<Integer> integers2 = Arrays.asList(outer);
    List<Integer> integers1 = Arrays.asList(inner);
    return integers2.containsAll(integers1);
}

public static boolean checkPrimitives(int[] outer, int[] inner) {
    List<int[]> ints2 = Arrays.asList(outer);
    List<int[]> ints1 = Arrays.asList(inner);
    return ints2.containsAll(ints1); // compare object references not content
}

When passing primitives it compares the int[] object reference instead of comparing each element as you would want to.

Answer 3

Two simple solutions.

The idea in both is to see, for each element x in the first list, whether it is in the second list. If it is, we focus on the remaining part of the list (subList).

The second method works, because indexOf returns -1 if the element was not found.

private static boolean test(List<Integer> list1, List<Integer> list2) {
    int i = 0;
    for (int x : list1) {
        List<Integer> tempList = list2.subList(i, list2.size());
        if (tempList.contains(x)) {
            i = list2.indexOf(x);
        }
        else return false;
    }
    return true;
}

private static boolean test2(List<Integer> list1, List<Integer> list2) {
    int i = 0;
    int j = 0;
    int len = list2.size();
    
    for (int x : list1) {
        j = list2.subList(i, len).indexOf(x);
        if (j < 0) return false;
        i += j;
    }
    
    return true;
}