Java二维阵列；来自文件输入的可变行和列长度

Question

对于这个intro级赋值，我必须从一个文件和一个double[][]a设置一个2D多维数组，并对它们应用几种方法。现在，我主要关心的是初始化数组。我在想办法取一个测试文件，读取第一个int作为行数，每行的第一个整数作为每行的列数，每个double作为数组的成员。

 public class MDArray
    {
        static int rowCount;
        static int columnCount;
        private static double[][] mdarray = new double[rowCount][columnCount];

    public MDArray(double[][] a)
    {
        mdarray = a;
    }

    public MDArray(String file)
    {
        Scanner input = null;
        try
        {
            input = new Scanner(new FileInputStream("ragged.txt"));
        }
        catch (FileNotFoundException e)
        {
            System.out.println("File Not Found.");
            System.exit(0);
        }
        while(input.hasNextDouble())
        {
            rowCount = input.nextInt();
            for(int i = 0; i < rowCount; i++)
            {
                columnCount = input.nextInt();
                for(int j = 0; j < columnCount; j++)
                {
                    double value = input.nextDouble();
                    mdarray[i][j] = value;
                }
            }
        }
    }

    public static boolean isRagged()
    {
        for(int i = 0; i < mdarray.length; i++)
        {
            int rowLength1 = mdarray.length;
            for(int j = i + 1; j < mdarray.length; j++)
            {
                int rowLength2 = mdarray.length;
                if(rowLength1 != rowLength2)
                {
                    return true;
                }
            }
        }
        return false;
    }

    public static int getNumberOfRows()
    {
        int numRows = 0;
        for(int i = 0; i < mdarray.length; i++)
        {
            numRows++;
        }
        return numRows;
    }

    public static int getNumberOfCols()
    {
        int numCols = 0;
        for(int i = 0, j = i + 1; i < mdarray.length; i++)
        {
            for(int k = 0; k < mdarray[i].length; k++)
            {
                if(mdarray[i].length > mdarray[j].length)
                {
                    numCols++;
                }
            }
        }
        return numCols;
    }

    public static double getValAt(int i, int j)
    {
        if(i > mdarray.length || j > mdarray[i].length)
        {
            double invalid = Double.NaN;
            return invalid;
        }
        double valAt = mdarray[i][j];
        return valAt;
    }

    public static void sort(boolean byColumn)
    {
        if(isRagged() == true)
        {
            System.out.println("Ragged arrays cannot be sorted by column.");
        }
        else{
            for(int i = 0; i < mdarray.length; i++)
            {
                for(int j = 0; j < mdarray[i].length; j++)
                {
                    for(int k = j + 1; k < mdarray[i].length; k++)
                    {
                        if(mdarray[i][j] < mdarray[i][k])
                        {
                            double temp = mdarray[i][j];
                            mdarray[i][k] = mdarray[i][j];
                            mdarray[i][j] = temp;
                        }
                    }
                }
            }
        }
    }

    public static int hamming(boolean byColumn)
    {
        int hamVal = 0;
        if(isRagged() == true)
        {
            System.out.println("Ragged arrays cannot be sorted by column.");
        }
        else{
            for(int i = 0; i < mdarray.length; i++)
            {
                for(int j = 0; j < mdarray[i].length; j++)
                {
                    for(int k = j + 1; k < mdarray[i].length; k++)
                    {
                        if(mdarray[i][j] < mdarray[i][k])
                        {
                            double temp = mdarray[i][j];
                            mdarray[i][k] = mdarray[i][j];
                            mdarray[i][j] = temp;
                            hamVal++;
                        }
                    }
                }
            }
        }
        return hamVal;
    }

    public static double[] max()
    {
        double[] maxVal = new double[mdarray.length];
        for(int i = 0, j = i + 1; i < maxVal.length; i++)
            {
                for(int k = 0; k < mdarray[i].length; k++)
                {
                    if(mdarray[i][k] > mdarray[j][k])
                    {
                        maxVal = mdarray[i];
                    }
                }
            }
        return maxVal;
    }

    public String toString()
    {
        String arrayString = "";
        for(int i = 0; i < mdarray.length; i++)
        {
            for(int j = 0; j < mdarray[i].length; j++)
            {
                arrayString += ", " + mdarray[i][j];
            }
            arrayString = arrayString + "/n";
        }
        return arrayString;
    }
}

这是我用来测试MDArray（字符串文件）的文件：

3

2 4.1 8.9

5 9.5 2.0 7.3 2.1 8.9

3 1.3 5.2 3.4

我认为问题是rowcount和columncount整数没有初始化，但我不确定如何用基本数组技巧将它们初始化为可变长度。这也会影响其他构造函数。作为入门级课程，我不应该使用更高级的技术，如arraylist。此外，我无法验证这些方法是否正确，因为我没有用来测试它们的数组。

编辑：虽然我确实实现了答案中的许多建议，例如将所有内容更改为非静态和其他更改，但我仍然得到一个NullPointerException行MDARRAY[I][j]=Input.NextDouble（）；。我假设它与私有的Double[][]MDARRAY有关，这是赋值规范中所必需的。现在我试图找到一种方法来初始化它，这样它就可以在后面的方法中被重写。

Answer 1

您必须在构造函数中初始化数组，因为这时您才知道维度：

public MDArray(String file)
{
    Scanner input = null;
    try {
        input = new Scanner(new FileInputStream("ragged.txt"));
    }
    catch (FileNotFoundException e) {
        System.out.println("File Not Found.");
        System.exit(0);
    }
    rowCount = input.nextInt(); 
    mdarray = new double[rowCount][]; // init the array
    for(int i = 0; i < rowCount; i++) {
        columnCount = input.nextInt();
        mdarray[i] = new double[columnCount]; // init the current row
        for(int j = 0; j < columnCount; j++) {
            mdarray[i][j] = input.nextDouble();
        }
    }

}