Java 流表达式解析字符串为 double[m][n]（n 大小不同）

Question

作为解析配置字符串的一部分，我想将字符串转换为 double[][] 数组。 配置字符串包含一个或多个 ( m ) 三个或更多 ( n ) 个元素的集合。

对于输入： "0,0,0 | 500,0,10 | 0,300,20 | 500,300,30" ,
我希望输出： double[][]{{0,0,0},{500,0,10},{0,300,20},{500,300,30}}

下面的清单有效，但是，我想改进代码如下（我很难实现）：

1. 对于可变数量的 n 个元素，使代码通用，以便它接受诸如“0,0,0 | 500,0,10 | 0,300,20, 999 | 500,300,30”之类的输入，其中输出[2] = [0,300,20,999]。 我目前使用（ map(x -> new double[]{Double.parseDouble(x[0]),Double.parseDouble(x[1]),Double.parseDouble(x[2])}) ）我想要一般重写。
2. 理想的情况是在两个流表达式组合成一个表达，以在字符串中和一气呵成输出所述双[M] [N]。 这可能吗？

清单：

    String ss = "0,0,0  | 500,0,10  |  0,300,20  | 500,300,30";
    System.out.println(ss);
    
    String[][] result_s = 
            Arrays.
            stream(ss.split("\\|")).
            map(x -> x.trim().split(",")).
            toArray(size -> new String[size][1]);
    double[][] result_d = 
            Arrays.stream(result_s).
            //This next line is the embarrassing part and I would like to make it generic (so independent of number of elements
            map(x -> new double[]{Double.parseDouble(x[0]),Double.parseDouble(x[1]),Double.parseDouble(x[2])})
            .toArray(size -> new double[size][1]);
    
    double[][] result_new = Arrays.stream(ss.split("\\|")).collect(Collectors.toList(entry -> entry.x.trim().split(",")));
            Arrays.
            stream(ss.split("\\|")).
            map(x -> x.trim().split(",")).
            map(x -> new double[]{Double.parseDouble(x[0]),Double.parseDouble(x[1]),Double.parseDouble(x[2])}).
            toArray(size -> new String[size][1]);
    
    //Strings array
    System.out.println("String arrays");
    for(String[] rs : result_s) System.out.println(Arrays.toString(rs));
    
    //double array
    System.out.println("Double arrays");
    for(double[] rs : result_d) System.out.println(Arrays.toString(rs));

输出 ：

0,0,0 | 500,0,10 | 0,300,20 | 500,300,30
字符串数组
[0, 0, 0]
[500, 0, 10]
[0, 300, 20]
[500, 300, 30]
双数组
[0.0, 0.0, 0.0]
[500.0, 0.0, 10.0]
[0.0, 300.0, 20.0]
[500.0, 300.0, 30.0]

Answer 1

首先，对于“令人尴尬的线”，您可以流式传输每个x ，这是一个double[]和mapToDouble ：

.map(x -> Arrays.stream(x).mapToDouble(Double::parseDouble).toArray())

其次，这两个流可以非常简单地连接起来。 如果没有toArray(size -> new String[size][1]) ，第一个流是Stream<String[]> ，这也是Arrays.stream(result_s)产生的。

toArray将流转换为数组，而Arrays.stream将数组转换为流，因此Arrays.stream(result_s)有点撤销toArray(size -> new String[size][1])所做的。 两条线可以相互抵消。

double[][] result_d =
        Arrays.stream(ss.split("\\|"))
                .map(x -> x.trim().split(","))
                .map(x -> Arrays.stream(x).mapToDouble(Double::parseDouble).toArray())
                .toArray(double[][]::new);