Java 二维阵列问题

好的，我在类中有一个赋值，写一个方法，返回2D数组中最大元素的位置。返回值是一个一维数组，其中包含两个元素，表示二维数组中最大元素的行和列

public static void main(String[] args) {
    int[] loc=new int[2];
    Scanner scan=new Scanner(System.in);
    int x,y;
    System.out.print("Enter the size of your two-dimensional array. Length then height: ");
    x=scan.nextInt();
    y=scan.nextInt();
    double [][]matrix=new double[x][y];
    System.out.println("Enter your two-dimensional array row by column: ");
    for (int i=0;i<y;i++){
        for (int j=0;j<x;j++){
            matrix[j][i]=scan.nextDouble();
            System.out.print("i: "+i+" j: "+j + " ");
        }
        System.out.println();
    }
    System.out.println();
    for (int i = 0; i<x; i++){
        for (int j = 0; j<y; j++){

            System.out.print(matrix[i][j] + ("i: "+i+" j: "+j + " "));

        }
         System.out.println();
    }
    loc=locateLargest(matrix,x,y);
        System.out.println(matrix[loc[0]][loc[1]]);


}
public static int[] locateLargest(double[][] a ,int x, int y){
    int m=0,n=0;
    int[] location={0,0};
    double largest=a[0][0];
    for (int i=0;i<x;i++){
        for (int j=0;j<y;j++){
            System.out.println("X: "+i+" Y: "+j +" value: " + a[i][j]);
            if (a[i][j]>largest){

                location[0]=i;
                m=i;
                location[1]=j;
                n=i;
            }
        }
    }
    System.out.println("the location of the largest element of you two-dimensional array is : ("  + location[0] + ", " + location[1] + ")");
    System.out.println(a[m][n]);
    return location;
}

publicstaticvoidmain（字符串[]args）{
int[]loc=新的int[2]；
扫描仪扫描=新扫描仪（System.in）；
int x，y；
System.out.print（“输入二维数组的大小。长度然后高度：”）；
x=scan.nextInt（）；
y=scan.nextInt（）；
double[]矩阵=新的double[x][y]；
System.out.println（“按列逐行输入二维数组：”；
对于（int i=0；i在块中找到较大值后，需要重新分配变量
最大值
：

        if (a[i][j]>largest){
            largest=a[i][j]; //current value is largest
            location[0]=i;
            location[1]=j;
        }

删除变量
m
和
n
，它们是多余的。
我认为您使用循环的方法找到最大数是正确的，唯一的问题是没有在
locateLargest
函数中重新分配最大值

public static int[] locateLargest(double[][] a ,int x, int y)
{
    int m=0,n=0;
    int[] location={0,0};
    double largest=a[0][0];
    for (int i=0;i<x;i++)
    {
        for (int j=0;j<y;j++)
        {
            System.out.println("X: "+i+" Y: "+j +" value: " + a[i][j]);
            if (a[i][j]>largest)
            {
                location[0]=i;
                m=i; //Why you need this extra variables 
                location[1]=j;
                n=i; //Why you need this extra variables 
                largest = a[i][j];
            }
        }
    }
    System.out.println("the location of the largest element of you two-dimensional array is : ("  + location[0] + ", " + location[1] + ")");
    System.out.println(a[m][n]);
    return location;
}

public static int[]locateLargest（双[]a，int x，int y）
{
int m=0，n=0；
int[]位置={0,0}；
双最大=a[0][0]；
对于（int i=0；i这个问题已经得到了回答，但我认为也值得您思考如何解决这类问题，而不必询问堆栈溢出。即使您的作业没有要求，我强烈建议您考虑开始进行测试驱动开发（TDD）——

如果没有，至少尝试“减少反馈循环”。例如，下面的代码块允许您轻松（直观地）构建可以使用的测试数组（而不是每次需要测试代码时都需要用户输入）

这将允许您在代码中构建5个稍有不同的数组，并查看哪些数组失败，这将帮助您找出原因

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class LargestNumber {

    public static void main(String[] args){
        TableBuilder<Integer> tableBuilder = new TableBuilder<Integer>()
                .row(1,   2, 3)
                .row(3,   2, 1)
                .row(3, 100, 1);
        print(tableBuilder.build());
    }


    static class TableBuilder<T>{
        List<List<T>> table = new ArrayList<List<T>>();

        TableBuilder<T> row(T... rowData){
            table.add(Arrays.asList(rowData));
            return this;
        }

        T[][] build(){
            T[][] tableAsArray = (T[][]) new Object[table.size()][];
            int arrayIndex = 0;
            for(List<T> row: table){
                tableAsArray[arrayIndex++] = (T[])row.toArray() ;
            }
            return tableAsArray;
        }
    }

    static void print(Object[][] table){
        for(Object[] row:table){
            for(Object cell:row){
                System.out.print(String.format("%1$" + 5 + "s", cell));
            }
            System.out.println();
        }

    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
公共类最大数{
公共静态void main（字符串[]args）{
TableBuilder TableBuilder=新的TableBuilder（）
.世界其他地区（1、2、3）
.世界其他地区（3、2、1）
。世界其他地区（3100,1）；
打印（tableBuilder.build（））；
}
静态类表生成器{
列表表=新的ArrayList（）；
TableBuilder行（T…行数据）{
add（Arrays.asList（rowData））；
归还这个；
}
T[][]构建（）{
T[][]表阵列=（T[][]）新对象[table.size（）][]；
int-arrayIndex=0；
对于（列表行：表）{
TableArray[arrayIndex++]=（T[]）行。toArray（）；
}
返回表数组；
}
}
静态无效打印（对象[][]表）{
对于（对象[]行：表）{
用于（对象单元格：行）{
系统输出打印（字符串格式（“%1$”+5+“s”，单元格））；
}
System.out.println（）；
}
}
}
不应该
n=i；
是
n=j；
？你为什么要再次使用位置？你还可以在循环中切换
x
和
y
。你可以在forloop中切换索引，该循环读取输入hank you Enermis。这就是它现在工作的问题。谢谢你的这一步。但是现在我得到了最大的数字（45）在错误的位置（0,2）这让我回想起我组装的阵列是错误的。m和n用于我的故障排除，但我现在明白了为什么即使在这种情况下它们仍然是冗余的。@user3098428您为x和y输入了什么值？您的x和y值可能有问题，为您的阵列获得了正确的输出，在我的回答中附加了代码仍然获得（0,2）作为答案。我在Enermis comment上阅读了上面的内容，并且能够解决剩余的问题。感谢您的帮助。45仍然得到（0，2）。我几乎可以肯定问题在于我现在安排阵列的方式。感谢您的帮助。我非常感谢您在回答问题之外添加更多帮助。