Java 如何确定数组是否包含单独数组中的所有整数

我在学校的ap计算机科学课上，我被困在这个问题上。甚至不能想出一个解决的办法

这里是逐字逐句的： 编写一个名为

的静态方法，该方法包含

，该方法接受两个整数数组a1和a2作为参数，并返回一个布尔值，指示a2的元素序列是否出现在a1中（true表示是，false表示否）。a2中的元素序列可能出现在a1中的任何位置，但必须连续出现，且顺序相同。例如，如果名为list1和list2的变量存储以下值：

int[] list1 = {1, 6, 2, 1, 4, 1, 2, 1, 8};
int[] list2 = {1, 2, 1};

然后调用

contains（list1，list2）

应该返回true，因为list2的值序列

{1，2，1}

包含在从索引5开始的list1中。如果list2存储了值

{2，1，2}

，则调用

包含（list1，list2）

将返回false，因为list1不包含该值序列。具有相同元素的任何两个列表都被视为相互包含，因此像

contains（list1，list1）

这样的调用应该返回true

您可以假设传递给方法的两个数组的长度至少为1。您不能使用任何字符串来帮助您解决此问题，也不能使用生成字符串的方法，如array.toString

如果有人能给我指出正确的方向那就太好了

这里还有一个我提出的尝试，但它没有足够的测试次数

public static boolean contains(int[] set1, int[] set2) {
    boolean contains = false;
    for (int i = 0; i < set1.length; i++) {
        for (int a = 0; a < set2.length - 1; a++) {
            if (set1[i] == set2[a] && set1[i + 1] == set2[a + 1]) {
                contains = true;
            } else {
                contains = false;
            }
        }
    }
    return contains;
}

公共静态布尔包含（int[]set1，int[]set2）{
布尔包含=假；
对于（int i=0；i

从

int first=list2[0]开始

然后在

列表1

中找到该数字。接下来，循环查看

list2

中的所有值，同时从先前找到的位置循环查看

list1

，直到验证整个

list2

是否存在于

list1

中或发现差异。如果发现不一致，则在先前找到的位置之后，首先用

重新启动

厚颜无耻地复制另一个答案：

public static boolean contains(int[] set1, int[] set2) {
    for (int i = 0, j = 0; i < set1.length; i++) {
        if (set1[i] == set2[j]) {
            if (++j >= set2.length)
                return true;
        }
        else {
            i -= j;
            j = 0;
        }
    }
    return false;
}

公共静态布尔包含（int[]set1，int[]set2）{
for（int i=0，j=0；i=set2.length）
返回true；
}
否则{
i-=j；
j=0；
}
}
返回false；
}

这种连续版本机制还确保在没有任何额外检查的情况下不会发生溢出。
从
int first=list2[0]开始
然后在
列表1
中找到该数字。接下来，循环查看
list2
中的所有值，同时从先前找到的位置循环查看
list1
，直到验证整个
list2
是否存在于
list1
中或发现差异。如果发现不一致，则在先前找到的位置之后，首先用
重新启动

厚颜无耻地复制另一个答案：

public static boolean contains(int[] set1, int[] set2) {
    for (int i = 0, j = 0; i < set1.length; i++) {
        if (set1[i] == set2[j]) {
            if (++j >= set2.length)
                return true;
        }
        else {
            i -= j;
            j = 0;
        }
    }
    return false;
}

公共静态布尔包含（int[]set1，int[]set2）{
for（int i=0，j=0；i=set2.length）
返回true；
}
否则{
i-=j；
j=0；
}
}
返回false；
}

这种连续版本机制还确保在没有任何额外检查的情况下不会发生溢出。
对于连续版本

public static boolean contains(int[] set1, int[] set2) {
     OUTER:
     for (int i = 0; i < set1.length - set2.length; i++) {
         for (int j = 0; j < set2.length; j++) {
             if (set1[i + j] != set2[j])
                  continue OUTER;
         }
         return true;
     } 
     return false;
}

公共静态布尔包含（int[]set1，int[]set2）{
外部：
对于（int i=0；i


为了避免标签，可以使用更清晰的方法

public static boolean contains(int[] set1, int[] set2) {
     for (int i = 0; i < set1.length - set2.length; i++)
         if (!matches(set1, i, set2))
             return false;
     return true;
}

public static boolean matches(int[] set1, int off, int[] set2) {
     for (int j = 0; j < set2.length; j++)
         if (set1[off + j] != set2[j])
               return false;
     return true;
}

公共静态布尔包含（int[]set1，int[]set2）{
对于（int i=0；i


如果它只需要有序的话

public static boolean contains(int[] set1, int[] set2) {
     for (int i = 0, j = 0; i < set1.length; i++)
         if (set1[i] == set2[j]) 
             if (++j >= set2.length)
                 return true;
     return false;
}

公共静态布尔包含（int[]set1，int[]set2）{
for（int i=0，j=0；i=set2.length）
返回true；
返回false；
}
用于连续

public static boolean contains(int[] set1, int[] set2) {
     OUTER:
     for (int i = 0; i < set1.length - set2.length; i++) {
         for (int j = 0; j < set2.length; j++) {
             if (set1[i + j] != set2[j])
                  continue OUTER;
         }
         return true;
     } 
     return false;
}

公共静态布尔包含（int[]set1，int[]set2）{
外部：
对于（int i=0；i


为了避免标签，可以使用更清晰的方法

public static boolean contains(int[] set1, int[] set2) {
     for (int i = 0; i < set1.length - set2.length; i++)
         if (!matches(set1, i, set2))
             return false;
     return true;
}

public static boolean matches(int[] set1, int off, int[] set2) {
     for (int j = 0; j < set2.length; j++)
         if (set1[off + j] != set2[j])
               return false;
     return true;
}

公共静态布尔包含（int[]set1，int[]set2）{
对于（int i=0；i


如果它只需要有序的话

public static boolean contains(int[] set1, int[] set2) {
     for (int i = 0, j = 0; i < set1.length; i++)
         if (set1[i] == set2[j]) 
             if (++j >= set2.length)
                 return true;
     return false;
}

公共静态布尔包含（int[]set1，int[]set2）{
for（int i=0，j=0；i=set2。