将CSV文件读取到数组中

1. Overview

Simply put, a CSV (Comma-Separated Values) file contains organized information separated by a comma delimiter.

In this tutorial, we’ll look into different ways to read a CSV file into an array.

2. BufferedReader in java.io

First, let’s read the records line by line using readLine() in BufferedReader and then split each line into tokens based on the comma delimiter:

List<List<String>> records = new ArrayList<>();
try (BufferedReader br = new BufferedReader(new FileReader("book.csv"))) {
    String line;
    while ((line = br.readLine()) != null) {
        String[] values = line.split(COMMA_DELIMITER);
        records.add(Arrays.asList(values));
    }
}

Note that more sophisticated CSVs (quoting or including commas as values) will not be parsed as intended with this approach.

3. Scanner in java.util

Next, let’s use a java.util.Scanner to run through the contents of the file and retrieve lines serially, one by one:

List<List<String>> records = new ArrayList<>();
try (Scanner scanner = new Scanner(new File("book.csv"))) {
    while (scanner.hasNextLine()) {
        records.add(getRecordFromLine(scanner.nextLine()));
    }
}

Next, let’s parse the lines and store them in an array:

private List<String> getRecordFromLine(String line) {
    List<String> values = new ArrayList<String>();
    try (Scanner rowScanner = new Scanner(line)) {
        rowScanner.useDelimiter(COMMA_DELIMITER);
        while (rowScanner.hasNext()) {
            values.add(rowScanner.next());
        }
    }
    return values;
}

Like before, more sophisticated CSVs will not be parsed as intended with this approach.

4. OpenCSV

We can address more complex CSV files with OpenCSV.

OpenCSV is a third-party library that provides an API to work with CSV files.

We’ll use the readNext() method in CSVReader to read the records in the file:

List<List<String>> records = new ArrayList<List<String>>();
try (CSVReader csvReader = new CSVReader(new FileReader("book.csv"));) {
    String[] values = null;
    while ((values = csvReader.readNext()) != null) {
        records.add(Arrays.asList(values));
    }
}

To dig deeper and learn more about OpenCSV, check out our OpenCSV tutorial.

5. Using Files Utility Class

Alternatively, we can use the Files class to achieve the same objective. This utility class consists of several static methods that operate on files and directories. So, let’s see how to use it in practice.

5.1. Using Files#lines

The lines() method is one of the enhancements introduced in Java 8. It allows us to read all lines of a given file as a stream. So, let’s see it in action:

try (Stream<String> lines = Files.lines(Paths.get(CSV_FILE))) {
    List<List<String>> records = lines.map(line -> Arrays.asList(line.split(COMMA_DELIMITER)))
      .collect(Collectors.toList());
}

Here, the Paths.get(CSV_FILE) method returns a Path instance which denotes the path to the CSV file. Furthermore, we used the map() method to convert each line of the CSV file to a list of strings. Please notice that we used a try-with-resources to ensure that the file is closed automatically at the end.

5.2. Using Files#readAllLines

Similarly, Files offers the readAllLines() method as another alternative to achieve the same outcome. This method, like lines(), accepts a Path object as a parameter and returns directly a list containing each line of the specified CSV file:

List<List<String>> records = Files.readAllLines(Paths.get(CSV_FILE))
  .stream()
  .map(line -> Arrays.asList(line.split(COMMA_DELIMITER)))
  .collect(Collectors.toList());

Notably, we used the stream API to read the CSV file into a List<List>. An important caveat to mention here is that readAllLines() puts everything in memory at once, so don’t use it to read large files.

5.3. Using Files#newBufferedReader

Another option would be to use the newBufferedReader() method. It returns an instance of BufferedReader, which provides a way to read the file more efficiently.

Next, let’s learn how to use this method through an example:

try (BufferedReader reader = Files.newBufferedReader(Paths.get(CSV_FILE))) {
    List<List<String>> records = reader.lines()
      .map(line -> Arrays.asList(line.split(COMMA_DELIMITER)))
      .collect(Collectors.toList());
}

As shown above, we used the same logic as before to read the CSV file. Please note that newBufferedReader() is the best way to go when working with large files compared to other methods.

6. Conclusion

In this quick article, we explored different ways to read CSV files into an array.

As always, the full source code of the examples is available over on GitHub.

Persistence

REST

Security