Java 如何检查二维数组是否包含数组？

例如，给定一个二维数组

int[][] arr = { {2,3}, {53, 2}, {23,13} };

如何检查它是否包含数组

{53，2}

我有以下代码：

int[][] arr = {{1, 3}, {2, 2}, {2, 5}, {3, 1}, {3, 4}, {3, 7}, {4, 3}, {4, 6}, {5, 2}, {5, 5},
                     {5, 8}, {6, 4}, {6, 7}, {7, 3}, {7, 6}, {7, 9}, {8, 5}, {8, 8}, {9, 7}};
for(int i = 0; i < 11; i++) {
    for(int j = 0; j < 11; j++) {
        //here i want to check if arr contains the array {i, j} 
    }
}

int[]arr={1,3}，{2,2}，{2,5}，{3,1}，{3,7}，{4,3}，{4,6}，{5,2}，{5,5}，
{5, 8}, {6, 4}, {6, 7}, {7, 3}, {7, 6}, {7, 9}, {8, 5}, {8, 8}, {9, 7}};
对于（int i=0；i<11；i++）{
对于（int j=0；j<11；j++）{
//这里我想检查arr是否包含数组{i，j}
}
}

如何简单有效地完成此操作？

我倾向于在此类情况下使用：

    String arrAsString = Arrays.deepToString(arr);
    if(arrAsString.contains("[53, 2]"))
    {
        System.out.println("contains line");
    }

---

下面是一个代码示例。也许不是最好的，但它正在发挥作用

int[][] arr = {{1, 3}, {2, 2}, {2, 5}, {3, 1}, {3, 4}, {3, 7}, {4, 3}, {4, 6}, {5, 2}, {5, 5},
    {5, 8}, {6, 4}, {6, 7}, {7, 3}, {7, 6}, {7, 9}, {8, 5}, {8, 8}, {9, 7}};

    int[] search = new int[]{7, 3};
    boolean exist = false;
    for (int i = 0; i < arr.length; i++) {
        int j = 0;
        for (; j < arr[0].length; j++) {
            if (arr[i][j] != search[j]) {
                break;
            }
        }
        if (j == arr[0].length && arr[i][j-1] == search[j-1]) {
            exist = true;
            break;
        }
    }
    System.out.println(exist);

---

您应该遍历整个数组，分析值（基于索引）并与给定的元组进行比较。请注意，

array.length

将为您提供整个数组中正确的元素数，

array[i].length

也将为

i

标识的特定行提供相同的元素数，因此您无需手动处理（并不时更改）索引和数组大小/长度

公共类应用程序{
final static int[][]数组={YOUR_TUPLES_HERE}；
公共静态布尔包含（最终整数x，最终整数y）{
for（int i=0；i%s%n”，包含（3，1））；//true
System.out.printf（“==>%s%n”，包含（6，5））；//false
System.out.printf（“==>%s%n”，包含（9，9））；//false
}
}

如果您确定数组在第二维度上的元素不超过两个，则可以使用

1

而不是

array[i].length

---

或者，您可以将

{1，3}

建模为，例如，

点（x，y）

，这将使您的生活更轻松，除非这是您不能自由建模的类分配（或某种练习）。

如果您的Java版本和组织允许，您可以使用流管道：

    int[][] arr = {{1, 3}, {2, 2}, {2, 5}, {3, 1}, {3, 4}, {3, 7}, {4, 3}, {4, 6}, {5, 2}, {5, 5},
            {5, 8}, {6, 4}, {6, 7}, {7, 3}, {7, 6}, {7, 9}, {8, 5}, {8, 8}, {9, 7}};
    int[] lineToSearchFor = { 8, 5 };
    boolean arrayContainsLine = Arrays.stream(arr)
            .anyMatch(line -> Arrays.equals(line, lineToSearchFor));
    System.out.println(arrayContainsLine);

此代码段的输出为：

真的

---

流可以在Java 8和更高版本中使用。

检查每行的第一个元素和搜索行的第一个元素，如果它们相等，则循环该行中的其余元素，如果不匹配，则对其余行重复该过程。您的意思是说包含数组

{i，j}

，其中i和j是循环的索引？或者你指的是像

{53，2}

这样的特定数组吗？不是我的反对票。虽然我不认为这是非常有效的，特别是如果阵列非常大，看起来不太优雅，它确实达到了它的目的。KISS，保持简单和愚蠢。我想这种方法的最大优点是，你可以在一行中写入它（除非你想打印数组，否则显然不需要将字符串存储到自己的变量中）-但我同意，对于大数组，这可能不是最好的方法。线性搜索大数组（例如，1000 x 1000或更大）永远不会便宜。在很多情况下，我不认为这种特殊方法的成本会令人望而却步，但您必须自己进行观察和测量（这段代码不是我的风格）。非常简短、干净、好的解决方案：竖起大拇指：有趣的向下投票。向下投票是堆栈溢出生命的一部分，这很好。我很好奇这一条的解释（上面的投票已经解释过了，谢谢）。我想你可以等很久再解释，这条线从一开始就是一团混乱。谢谢，@maio290，我至少会把它作为解释的一部分。

    int[][] arr = {{1, 3}, {2, 2}, {2, 5}, {3, 1}, {3, 4}, {3, 7}, {4, 3}, {4, 6}, {5, 2}, {5, 5},
            {5, 8}, {6, 4}, {6, 7}, {7, 3}, {7, 6}, {7, 9}, {8, 5}, {8, 8}, {9, 7}};
    int[] lineToSearchFor = { 8, 5 };
    boolean arrayContainsLine = Arrays.stream(arr)
            .anyMatch(line -> Arrays.equals(line, lineToSearchFor));
    System.out.println(arrayContainsLine);