Question

基本上，我试图将2D数组与数组进行比较，如果元素在单个数组中与2D数组匹配，则2D数组会替换单个数组的值。我举个例子：

因此，有两个2D数组：

arrayOne = [[livesAt, fname, city], [worksAt, fname, company]]
arrayTwo = [[livesAt, x, y], [worksAt, x, z]]

一个阵列：

findOut = [x,y,z]

目标是arrayOne替换arrayTwo中的所有内容，并通过与arrayTwo进行比较找出findOut数组中的元素。

编辑：“x”的值读取数组中位置的值...即fname。因此，“x”的值必须是第一行和第二行（fname）的相同。

答案应该是：

arrayOne = [[livesAt, fname, city], [worksAt, fname, company]]
arrayTwo = [[livesAt, fname, city], [worksAt, fname, company]]
findOut = [fname,city,company]

我在我的代码中尝试了这个，如下所示：

for (int i = 0; i < arrayOne.length;i++ ) {
        for (int j = 0; j < arrayTwo.length; j++){
            for(int x = 0; x < findOut.length;x++){
                if(arrayTwo[i][j].equals(findOut[x])) {
                    arrayTwo[i] = arrayOne[i];
                    arrayTwo[j] = arrayOne[j];
                    findOut[x] = arrayOne[i][j];

                    System.out.println("Match found");
                }else{
                    System.out.println("Not found");
                }
        }
    }
}

除了findOut数组只替换第一个元素'x'而不替换其他元素外，其中大部分都有效。

[fname，y，z]

在循环中，它打印出来：

Not found
Not found
Not found
Match found
Not found
Not found
Not found
Not found
Not found
Match found
Not found
Not found

我强烈感觉我的循环存在问题。任何人都可以给我任何指示或建议如何解决这个问题？我一直试图解决这个问题，但只取得了一些进展。

Answer 1

问题是;当您使用i < arrayTwo.length给出for循环条件时，它只迭代2次，因为arrayTwo中只有2个数组。但是你想要遍历这两个数组的所有元素而你没有为它提供循环。

此外，当您找到匹配项时，您会动态更改arrayTwo和findOut数组值，并且当您尝试查找相同元素的匹配项时会导致不匹配。所以它错了。您需要存储以前的findOut值，以便在重复值时再次比较这些值（x, y, z）（即x中有两个arrayTwo值，并且第一场比赛，您使用x更改fname，因此不会有任何第二场比赛）。你可以这样做：

String[] temp = findOut.clone();

for (int i = 0; i < arrayTwo.length; i++) {
        for (int j = 0; j < arrayTwo[i].length; j++) {
            for (int x = 0; x < temp.length; x++) {
                if (arrayTwo[i][j].equals(temp[x])) {
                    arrayTwo[i][j] = arrayOne[i][j];
                    findOut[x] = arrayTwo[i][j];

                    System.out.println("Match found");
                }
                else {
                System.out.println("Not found");
                }
            }
        }
    }

阵列将按预期更改：

arrayOne = [[livesAt, fname, city], [worksAt, fname, company]]
arrayTwo = [[livesAt, fname, city], [worksAt, fname, company]]
findOut = [fname,city,company]

Answer 2

  if(arrayTwo[i][j].equals(findOut[x])) {   
       arrayTwo[i] = arrayOne[i];     // Here you are replacing the entire element. What you need to do is only replace that particular value using [i][j]
       arrayTwo[j] = arrayOne[j];
       findOut[x] = arrayOne[i][j];
  }

您需要做的是，

  if(arrayTwo[i][j].equals(findOut[x])) {   
       arrayTwo[i][j] = arrayOne[i][j];          
       findOut[x] = arrayOne[i][j];
  }

此外，二维数组的.length将为您提供其中的数组数。不是每个数组中的元素数量。因此，为了获取适当的长度，你必须在其中获取一个数组并找到它的长度。

  for (int i = 0; i < arrayOne.length; i++) {
        for (int j = 0; j < arrayTwo[i].length; j++) {
            for (int x = 0; x < findOut.length; x++) {
                if (arrayTwo[i][j].equals(findOut[x])) {                        
                    findOut[x] = arrayOne[i][j];
                    System.out.println("Match found");
                } else {
                    System.out.println("Not found");
                }
            }
        }
    }

Answer 3

我不认为这两行是正确的：

arrayTwo[i] = arrayOne[i];
arrayTwo[j] = arrayOne[j];

因为arrayTwo[i] = arrayOne[i]会导致if语句始终为真：
if(arrayTwo[i][j].equals(findOut[x]))

不应该是arrayTwo[i][j] = arrayOne[i][j];

Answer 4

您的问题不明确

如果数组看起来像这样会发生什么？

arrayOne = [[livesAt, fname, city], [worksAt, gname, company]]
arrayTwo = [[livesAt, x, y], [worksAt, x, z]]
findOut = [x,y,z]

结果是这个

arrayOne = [[livesAt, fname, city], [worksAt, gname, company]]
arrayTwo = [[livesAt, fname, city], [worksAt, gname, company]]
findOut = [fname,city,company]

或者

arrayOne = [[livesAt, fname, city], [worksAt, gname, company]]
arrayTwo = [[livesAt, fname, city], [worksAt, gname, company]]
findOut = [gname,city,company]

编辑：试试这个

import java.util.Arrays;

public class Test {
    private static int indexOf(String[] array, String str) {
        for(int i = 0; i < array.length; i++) if(array[i].equals(str)) return i;
        return -1;
    }

    private static String toString(String[][] array) {
        String str = "";
        for(String[] sa: array) str += ", " + Arrays.toString(sa);
        return "[" + str.substring(2) + "]";
    }

    public static void main(String[] args) {
        String[][] arrayOne = {{"livesAt", "fname", "city"}, {"worksAt", "fname", "company"}};
        String[][] arrayTwo = {{"livesAt", "x", "y"}, {"worksAt", "x", "z"}};
        String[] findOut = {"x","y","z"};

        String[] newFindOut = findOut.clone();
        for(int y = 0; y < arrayTwo.length; y++) {
            for(int x = 0; x < arrayTwo[y].length; x++) {
                int i = indexOf(findOut, arrayTwo[y][x]);
                if(i >= 0) {
                    arrayTwo[y][x] = arrayOne[y][x];
                    newFindOut[i] = arrayOne[y][x];
                }
            }
        }
        findOut = newFindOut;

        System.out.println("arrayOne = " + toString(arrayOne));
        System.out.println("arrayTwo = " + toString(arrayTwo));
        System.out.println("findOut = " + Arrays.toString(findOut));
    }
}

Answer 5

我们正在比较arrayOne和arrayTwo

，因此不需要对findOut进行迭代

请注意，@ SpiderPig指出这有fname gname个问题（如果findOut引用x中的两个值，则会覆盖arrayOne个值arrayTwo }）尽管public static void method(String[][] arrayOne, String[][] arrayTwo, String[] findOut) { String[] findOutClone = findOut.clone();//Required for comparison, as we are mutating findOut for (int i = 0; i < arrayTwo.length; i++) { String[] arrTwo = arrayTwo[i]; for (int j = 0; j < arrTwo.length; j++) { String arrTwoEl = arrTwo[j]; for (int k = 0; k < findOutClone.length; k++) if (arrTwoEl.equals(findOutClone[k])) arrTwo[j] = findOut[k] = arrayOne[i][j]; } } }值将正确更新

{{1}}

将2D数组与数组进行比较，并替换匹配的元素

5 个答案: