Java read csv file with OpenCSV for efficient data parsing

Reading a CSV file in Java seems simple until you hit a comma inside a quoted field, a Windows CRLF ending, or a 500 MB export from a legacy system. This guide shows the best ways to java read csv file correctly, from a quick BufferedReader solution to safer library-based parsing with OpenCSV and Apache Commons CSV.

What you’ll learn

Best way to read CSV file in Java

A CSV file looks simple until production data arrives. The main reason naive parsing fails is that CSV rules are not the same as plain string splitting. Quoted commas, embedded newlines, BOM prefixes, and non-comma delimiters all break fragile code.

For simple internal files, native Java can be enough. For anything exported from Excel, a database, or a third-party system, a CSV library is the safer choice.

Read CSV file in Java with BufferedReader

If your CSV file is simple and predictable, BufferedReader is the fastest way to start. It has no external dependency and works well for internal files without quoted commas or multiline fields.

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

public class BasicCSVReader {
    public static List<String[]> readCSV(String filename) throws IOException {
        List<String[]> records = new ArrayList<>();

        try (BufferedReader reader = Files.newBufferedReader(
                Paths.get(filename), StandardCharsets.UTF_8)) {

            reader.readLine(); // skip header
            String line;

            while ((line = reader.readLine()) != null) {
                String[] fields = line.split(",", -1);
                records.add(fields);
            }
        }

        return records;
    }
}

Read CSV file in Java with OpenCSV

OpenCSV is a strong choice when you want quick setup, safer parsing, and direct mapping from CSV rows to Java objects. It is especially useful when your input contains quoted values, custom separators, or headers.

Maven:

<dependency>
    <groupId>com.opencsv</groupId>
    <artifactId>opencsv</artifactId>
    <version>LATEST_STABLE_VERSION</version>
</dependency>

Read row by row:

import com.opencsv.CSVReader;
import com.opencsv.CSVReaderBuilder;

import java.io.FileReader;

public class OpenCSVBasic {
    public static void main(String[] args) throws Exception {
        try (CSVReader reader = new CSVReaderBuilder(new FileReader("users.csv"))
                .withSkipLines(1)
                .build()) {

            String[] row;
            while ((row = reader.readNext()) != null) {
                System.out.println(row[0] + " | " + row[1]);
            }
        }
    }
}

Use a custom separator:

import com.opencsv.CSVParser;
import com.opencsv.CSVParserBuilder;
import com.opencsv.CSVReader;
import com.opencsv.CSVReaderBuilder;

import java.io.FileReader;
import java.util.Arrays;

public class OpenCSVCustomSeparator {
    public static void main(String[] args) throws Exception {
        CSVParser parser = new CSVParserBuilder()
                .withSeparator(';')
                .withQuoteChar('"')
                .build();

        try (CSVReader reader = new CSVReaderBuilder(new FileReader("data.csv"))
                .withCSVParser(parser)
                .withSkipLines(1)
                .build()) {

            String[] row;
            while ((row = reader.readNext()) != null) {
                System.out.println(Arrays.toString(row));
            }
        }
    }
}

Read CSV file in Java with Apache Commons CSV

Apache Commons CSV is a great option when you want clean header-based access, format presets, and predictable parsing behavior. It is especially useful for ETL code, batch imports, and files that come from Excel or external systems.

Maven:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-csv</artifactId>
    <version>LATEST_STABLE_VERSION</version>
</dependency>

Read CSV with headers:

import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVRecord;

import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Path;

public class CommonsCsvExample {
    public static void main(String[] args) throws Exception {
        try (Reader reader = Files.newBufferedReader(Path.of("users.csv"));
             CSVParser parser = CSVFormat.DEFAULT
                     .builder()
                     .setHeader()
                     .setSkipHeaderRecord(true)
                     .setIgnoreHeaderCase(true)
                     .setTrim(true)
                     .build()
                     .parse(reader)) {

            for (CSVRecord record : parser) {
                System.out.println(record.get("name") + " - " + record.get("email"));
            }
        }
    }
}

Use a custom format:

import org.apache.commons.csv.CSVFormat;

CSVFormat format = CSVFormat.DEFAULT
        .builder()
        .setDelimiter('|')
        .setQuote('"')
        .setHeader()
        .setSkipHeaderRecord(true)
        .build();

Which Java CSV library should you use?

Read CSV header and map rows to Java objects

If you want cleaner code, map CSV rows to Java objects instead of working with raw string arrays. This makes your import code easier to validate, test, and pass into service classes.

import com.opencsv.bean.CsvBindByName;
import com.opencsv.bean.CsvToBeanBuilder;

import java.io.FileReader;
import java.util.List;

public class Product {
    @CsvBindByName(column = "name")
    private String name;

    @CsvBindByName(column = "price")
    private double price;

    @CsvBindByName(column = "category")
    private String category;

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    public String getCategory() {
        return category;
    }
}

public class BeanReader {
    public static List<Product> read(String filename) throws Exception {
        return new CsvToBeanBuilder<Product>(new FileReader(filename))
                .withType(Product.class)
                .withIgnoreLeadingWhiteSpace(true)
                .build()
                .parse();
    }
}

Read CSV with different separators and encodings

One of the most common production issues is a file that looks correct in a text editor but breaks in Java. In most cases, the root cause is either the wrong delimiter or the wrong character encoding.

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;

public class EncodingExample {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = Files.newBufferedReader(
                Path.of("data.csv"), StandardCharsets.UTF_8)) {

            String line;
            while ((line = reader.readLine()) != null) {
                String[] fields = line.split(";", -1);
                System.out.println(Arrays.toString(fields));
            }
        }
    }
}

How to read large CSV files in Java

For large CSV files, the main rule is simple: process rows as a stream instead of loading everything into memory. In practice, that means using BufferedReader, OpenCSV’s readNext(), or Apache Commons CSV iteration.

import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVRecord;

import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Path;

public class LargeCsvExample {
    public static void main(String[] args) throws Exception {
        try (Reader reader = Files.newBufferedReader(Path.of("large-file.csv"));
             CSVParser parser = CSVFormat.DEFAULT
                     .builder()
                     .setHeader()
                     .setSkipHeaderRecord(true)
                     .build()
                     .parse(reader)) {

            for (CSVRecord record : parser) {
                // Process one row at a time
                System.out.println(record.get(0));
            }
        }
    }
}

Common CSV reading errors in Java

Production-safe CSV processing means reading row by row, validating field counts, logging malformed records, and mapping valid rows into structured Java objects as early as possible.

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

public class ValidatingCSVReader {

    public record ParseResult(List<String[]> valid, List<String> errors) {}

    public static ParseResult parse(String filename) throws IOException {
        List<String[]> valid = new ArrayList<>();
        List<String> errors = new ArrayList<>();
        int lineNum = 0;

        try (BufferedReader reader = Files.newBufferedReader(Paths.get(filename))) {
            reader.readLine(); // skip header
            String raw;

            while ((raw = reader.readLine()) != null) {
                lineNum++;
                String[] fields = raw.split(",", -1);

                if (fields.length != 3) {
                    errors.add("Line " + lineNum + ": expected 3 fields, got " + fields.length);
                    continue;
                }

                valid.add(fields);
            }
        }

        return new ParseResult(valid, errors);
    }
}