Java中大小未知的数组

我正在用Java写一个程序来做一些不同的数学运算和公式，其中之一就是矩阵加法。我需要一种方法来创建一个由用户决定大小的数组。我可以让用户输入数组的维度，但我想要一种更无缝的方法。我决定输入数组的内容，输入不同行的逗号分隔的内容，并按不同数字的空格（对于3x3数组，键入1 2 3、4 5 6、7 8 9）分隔，这就是我所想到的代码。（sc是扫描仪）

其中，它将用逗号分隔不同的行，并用空格分隔行中的列。我认为Java中不存在类似的东西，但如果它存在，那就太好了。否则的话，我会很感激你能给我提供的一切帮助。如果没有简单的解决方案，我可能只需要让用户键入数组维度

---

编辑：如果这是不可能的，那么如果其他人有存储矩阵的工作方法，那就太好了。

我假设您不想使用ArrayList，因为您更愿意使用内部函数（double）而不是对象（double），如果不是这样的话，就使用ArrayList

如果这是原因，请输入ArrayList，然后当它已满时，将其转换为数组。ArrayList将比您可能编写的任何代码都做得更好，并且可读性更高

虽然数组通常对本质有意义，但90%的时候我无法理解人们对数组的迷恋（超过了ArrayList）。即使您希望为操作的特定部分使用数组，通常最好将其保留为ArrayList 90%的时间，然后在需要时将其转换为数组

评论中的问题： 数组列表只是一个用一些方法包装并优化的数组。例如，如果您不想给它一个尺寸，您不必给它一个尺寸，您可以使用：

ArrayList al=new ArrayList();
al.add(0, "first");
al.add(1, "second");

在内部，它将存储为一个包含2个字符串的数组。如果你要的是.size（），它会说是2。实际的存储比您一开始想象的要优化一些，但您只需将其视为一个阵列，例如，在上面的示例中，您可以说：

al.get(1);

并获得“秒”（它们与数组一样是零基的）

当您向ArrayList添加更多内容时，它将根据需要扩展其底层存储—您永远不必考虑它

如果需要，可以随时将ArrayList转换为数组

以下是一些“转换”

//声明
int[]a；
ArrayList al；
//实例化
a=新整数[6]；
al=新阵列列表（6）；//或al=新的ArrayList（）；让它自己扩展
//增加价值
a[0]=5；a[1]=6；
al.添加（0,5）；加上（1,6）；//注意，如果索引大于
//如果大于列表大小，则数组
//列表中的存储将自动展开
//检索值
x=a[1]；
x=al.get（1）；
//覆盖值
a[0]=9；
al.添加（0,9）；
//查找数组大小：
len=a.长度；
len=所有尺寸（）；
//迭代：
对于（int i:a）。。。
对于（int i:al）…//是的，一模一样

---

主要的优点是，在eclipse中，如果您键入al，您将获得许多非常有用的方法，但是如果您键入a。您不会得到太多，您必须在Arrays类中查找实用程序方法，并通过这些方法来解决问题。这就是ArrayList管理其自身大小的方式…

我假设您不想使用ArrayList，因为您更愿意使用内部函数（double）而不是对象（double），如果不是这样的话，就使用ArrayList吧

如果这是原因，请输入ArrayList，然后当它已满时，将其转换为数组。ArrayList将比您可能编写的任何代码都做得更好，并且可读性更高

虽然数组通常对本质有意义，但90%的时候我无法理解人们对数组的迷恋（超过了ArrayList）。即使您希望为操作的特定部分使用数组，通常最好将其保留为ArrayList 90%的时间，然后在需要时将其转换为数组

评论中的问题： 数组列表只是一个用一些方法包装并优化的数组。例如，如果您不想给它一个尺寸，您不必给它一个尺寸，您可以使用：

ArrayList al=new ArrayList();
al.add(0, "first");
al.add(1, "second");

在内部，它将存储为一个包含2个字符串的数组。如果你要的是.size（），它会说是2。实际的存储比您一开始想象的要优化一些，但您只需将其视为一个阵列，例如，在上面的示例中，您可以说：

al.get(1);

并获得“秒”（它们与数组一样是零基的）

当您向ArrayList添加更多内容时，它将根据需要扩展其底层存储—您永远不必考虑它

如果需要，可以随时将ArrayList转换为数组

以下是一些“转换”

//声明
int[]a；
ArrayList al；
//实例化
a=新整数[6]；
al=新阵列列表（6）；//或al=新的ArrayList（）；让它自己扩展
//增加价值
a[0]=5；a[1]=6；
al.添加（0,5）；加上（1,6）；//注意，如果索引大于
//如果大于列表大小，则数组
//列表中的存储将自动展开
//检索值
x=a[1]；
x=al.get（1）；
//覆盖值
a[0]=9；
al.添加（0,9）；
//查找数组大小：
len=a.长度；
len=所有尺寸（）；
//迭代：
对于（int i:a）。。。
对于（int i:al）…//是的，一模一样

---

主要的优点是，在eclipse中，如果您键入al，您将获得许多非常有用的方法，但是如果您键入a。您不会得到太多，您必须在Arrays类中查找实用程序方法，并通过这些方法来解决问题。这也是ArrayList管理自身大小的方式…

您可能希望使用Java8StreamsAPI来实现这种二维数组解析。以下草案实现将字符串解析为二维数组：

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Program {
    public static void main(final String[] args) {
        final String arrayString = "1 2 3, 4 5 6, 7 8 9";
        final List<List<Integer>> array = parseArray(arrayString);
        System.out.println(array);
    }

    private static List<List<Integer>> parseArray(final String arrayString) {
        final List<List<Integer>> rows = Arrays.stream(arrayString.split(","))
            .map(Program::parseRow)
            .collect(Collectors.toList());

        final long distinctColumnSizeCount = rows.stream()
            .map(List::size)
            .distinct()
            .count();
        if (distinctColumnSizeCount > 1) {
            throw new IllegalArgumentException("Some rows have different column count");
        }

        return rows;
    }

    private static List<Integer> parseRow(final String rowString) {
        return Arrays.stream(rowString.trim().split("\\s*"))
            .filter(((Predicate<String>) String::isEmpty).negate())
            .map(Integer::valueOf)
            .collect(Collectors.toList());
    }
}

导入java.util.array；
导入java.util.List；
导入java.util.function.Predicate；
导入java.util.stream.collector；
聚氨基甲酸酯
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Program {
    public static void main(final String[] args) {
        final String arrayString = "1 2 3, 4 5 6, 7 8 9";
        final List<List<Integer>> array = parseArray(arrayString);
        System.out.println(array);
    }

    private static List<List<Integer>> parseArray(final String arrayString) {
        final List<List<Integer>> rows = Arrays.stream(arrayString.split(","))
            .map(Program::parseRow)
            .collect(Collectors.toList());

        final long distinctColumnSizeCount = rows.stream()
            .map(List::size)
            .distinct()
            .count();
        if (distinctColumnSizeCount > 1) {
            throw new IllegalArgumentException("Some rows have different column count");
        }

        return rows;
    }

    private static List<Integer> parseRow(final String rowString) {
        return Arrays.stream(rowString.trim().split("\\s*"))
            .filter(((Predicate<String>) String::isEmpty).negate())
            .map(Integer::valueOf)
            .collect(Collectors.toList());
    }
}

String values = "1 2 3, 4 5 6, 7 8 9";
String[] pR = values.split(",");

// Declare and initialize your 2D String Array
String[][] dp = new String[pR.length][pR[0].trim().split("\\s+").length];

// Fill the 2D String Array
for (int i = 0; i < pR.length; i++) {
    String[] pC = pR[i].trim().split("\\s+");
    for (int j = 0; j < pC.length; j++) {
        dp[i][j] = pC[j]; 
    }
}

for (int i = 0; i < dp.length; i++) {
            System.out.print("Column Values in Row Index #" + i + " is: --> ");
    for (int j = 0; j < dp[i].length; j++) {
        System.out.print(dp[i][j] + ", ");
    }
    System.out.println("");
}

String values = "1 2 3, 4 5 6, 7 8 9";
String[] pR = values.split(",");

// Declare and initialize your 2D Integer Array
int[][] dp = new int[pR.length][pR[0].trim().split("\\s+").length];

// Fill the 2D Integer Array
for (int i = 0; i < pR.length; i++) {
    String[] pC = pR[i].trim().split("\\s+");
    for (int j = 0; j < pC.length; j++) {
        dp[i][j] = Integer.parseInt(pC[j]); 
    }
}