如何转换 ArrayList<string[]> 到包含十进制值的双[]？</string[]>

Question

I've taken in my inputs using a buffered reader, like so:

private static ArrayList<String[]> dataItem;
private static double[] CONVERT;

public static ArrayList<String[]> readData() throws IOException {
    String file = "numbers.csv";
    ArrayList<String[]> content = new ArrayList<>();
    try (BufferedReader br = new BufferedReader(new FileReader(file))) {
        String line = "";
        while ((line = br.readLine()) != null) {
            content.add(line.split(","));
        }
    } catch (FileNotFoundException e) { }
    return content;
}

I have a csv file with values like this:

0.2437,0.2235,0.9,0.2599,0.1051,0.1635,0.3563,0.129,0.1015
0.2441,0.3012,0.9,0.1123,0.1079,0.4556,0.4008,0.3068,0.1061
0.2445,0.4806,0.9,0.1113,0.1081,0.354,0.4799,0.3487,0.1034

I want to create a double array ( double[] ) so I can run through the file one line at a time in my program. How can I take the lines from the file and create this array from them?

Answer 1

Assuming that the CSV data are read successfully into List<String[]> , the conversion to 2D double array may be implemented like this using Stream API:

static double[][] convert2D(List<String[]> data) {
    return data.stream()
        .map(arr -> Arrays.stream(arr)
                .mapToDouble(Double::parseDouble).toArray()) // Stream<double[]>
        .toArray(double[][]::new);
}

---

If a simple double[] array is needed without keeping the lines, the contents of data may be converted using Stream::flatMapToDouble :

static double[] convert1D(List<String[]> data) {
    return data.stream()
        .flatMapToDouble(arr -> Arrays.stream(arr)
                .mapToDouble(Double::parseDouble)) // DoubleStream
        .toArray();
}

Answer 2

Instead of storing them in an intermediate List<String[]> why not just process them as you read them?

• Use Files.lines to read in the lines as a stream.
• split each line on a ,
• flatMap to a single stream
• convert to a double via Double::parseDouble
• and store in an array.

String file = "numbers.csv";
double[] results1D = null;
try {
    results1D = Files.lines(Path.of(file))
            .flatMap(line -> Arrays.stream(line.split(",")))
            .mapToDouble(Double::parseDouble).toArray();
    
} catch (IOException io) {
    io.printStackTrace();
}
System.out.println(Arrays.toString(results1D));

prints

[0.2437, 0.2235, 0.9, 0.2599, 0.1051, 0.1635, 0.3563, 0.129, 0.1015, 0.2441, 0.3
012, 0.9, 0.1123, 0.1079, 0.4556, 0.4008, 0.3068, 0.1061, 0.2445, 0.4806, 0.9, 0
.1113, 0.1081, 0.354, 0.4799, 0.3487, 0.1034]

Or you can store each line in an array and create a "2D" array.

• Use Files.lines to read in the lines as a stream.
• split each line on a ,
• stream the array
• convert each line to a double array
• and package all the double arrays into an array of arrays.

double[][] results2D = null;
try {
    results2D = Files.lines(Path.of(file))
            .map(line -> Arrays.stream(line.split(","))
                    .mapToDouble(Double::parseDouble)
                    .toArray())
            .toArray(double[][]::new);
    
} catch (IOException io) {
    io.printStackTrace();
}
for(double[] d : results2D) {
    System.out.println(Arrays.toString(d));
}

prints

[0.2437, 0.2235, 0.9, 0.2599, 0.1051, 0.1635, 0.3563, 0.129, 0.1015]
[0.2441, 0.3012, 0.9, 0.1123, 0.1079, 0.4556, 0.4008, 0.3068, 0.1061]
[0.2445, 0.4806, 0.9, 0.1113, 0.1081, 0.354, 0.4799, 0.3487, 0.1034]

Either way is more efficient by not having to iterate thru the input again.

Answer 3

You can use a single Stream for this purpose:

List<String[]> contents = List.of(
"0.2437,0.2235,0.9,0.2599,0.1051,0.1635,0.3563,0.129,0.1015".split(","),
"0.2441,0.3012,0.9,0.1123,0.1079,0.4556,0.4008,0.3068,0.1061".split(","),
"0.2445,0.4806,0.9,0.1113,0.1081,0.354,0.4799,0.3487,0.1034".split(","));

// convert a List<String[]> to a double[] using a single stream
double[] doubles = contents
        // Stream<String[]>
        .stream()
        // Stream<String>
        .flatMap(Arrays::stream)
        // DoubleStream
        .mapToDouble(Double::parseDouble)
        // double[]
        .toArray();

// output in three lines
IntStream.range(0, doubles.length)
        .forEach(i -> {
            if (i % 9 > 0)
                System.out.print(" ");
            else if (i > 0)
                System.out.println();
            System.out.print(doubles[i]);
        });

Output:

0.2437 0.2235 0.9 0.2599 0.1051 0.1635 0.3563 0.129 0.1015
0.2441 0.3012 0.9 0.1123 0.1079 0.4556 0.4008 0.3068 0.1061
0.2445 0.4806 0.9 0.1113 0.1081 0.354 0.4799 0.3487 0.1034