How to Read a CSV File in Java: A Complete Guide
Reading a CSV (Comma-Separated Values) file in Java is a common task for developers working with data processing, reporting, or data migration projects. While Java doesn't provide built-in CSV parsing capabilities in its standard library, there are several reliable libraries and approaches available to efficiently read CSV files. This complete walkthrough will walk you through multiple methods to read CSV files in Java, from basic approaches to using popular third-party libraries Turns out it matters..
Introduction to CSV File Handling in Java
CSV files are plain text files that store tabular data in a structured format, where each line represents a row and values are separated by commas. Java applications often need to import data from CSV files for analysis, database insertion, or business processing. Understanding how to properly read and parse CSV files is essential for any Java developer working with data.
Method 1: Reading CSV Files Using Standard Java Libraries
Basic Approach with BufferedReader and String.split()
The simplest way to read a CSV file in Java is by using the standard BufferedReader class along with String.split() method. This approach works well for simple CSV files without complex formatting.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class CSVReaderBasic {
public static void main(String[] args) {
String csvFile = "data.And = null) {
String[] fields = line. out.That said, csv";
String line;
String csvSplitBy = ",";
try (BufferedReader br = new BufferedReader(new FileReader(csvFile))) {
while ((line = br. Even so, print(field + " | ");
}
System. readLine()) !out.split(csvSplitBy);
for (String field : fields) {
System.println();
}
} catch (IOException e) {
e.
**Limitations of this approach:**
- Doesn't handle quoted fields containing commas
- Fails with multiline fields
- Lacks proper CSV specification compliance
- No support for different delimiters or escape characters
## Method 2: Using OpenCSV Library
OpenCSV is one of the most popular Java libraries for CSV processing. It provides solid parsing capabilities and handles complex CSV formats automatically.
### Setting Up OpenCSV
Add the following Maven dependency to your `pom.xml`:
```xml
com.opencsv
opencsv
5.7.1
Reading CSV with OpenCSV
import com.opencsv.CSVReader;
import com.opencsv.exceptions.CsvException;
import java.io.FileReader;
import java.io.IOException;
import java.util.List;
public class CSVReaderOpenCSV {
public static void main(String[] args) {
String csvFile = "data.That's why print(field + " | ");
}
System. Which means readAll();
for (String[] record : records) {
for (String field : record) {
System. Still, out. csv";
try (CSVReader reader = new CSVReader(new FileReader(csvFile))) {
List records = reader.out.println();
}
} catch (IOException | CsvException e) {
e.
### Reading CSV with Bean Mapping
OpenCSV also supports mapping CSV data directly to Java objects (beans):
```java
import com.opencsv.bean.CSVBindByName;
import com.opencsv.bean.CSVToBeanBuilder;
import java.io.Reader;
import java.io.FileReader;
import java.util.List;
class Product {
@CSVBindByName(column = "id")
private int id;
@CSVBindByName(column = "name")
private String name;
@CSVBindByName(column = "price")
private double price;
// Getters and setters
@Override
public String toString() {
return "Product [id=" + id + ", name=" + name + ", price=" + price + "]";
}
}
public class CSVReaderWithBeans {
public static void main(String[] args) {
String csvFile = "products.out.parse();
for (Product product : products) {
System.build()
.withType(Product.withIgnoreLeadingWhiteSpace(true)
.csv";
try (Reader reader = new FileReader(csvFile)) {
List products = new CSVToBeanBuilder(reader)
.class)
.println(product);
}
} catch (Exception e) {
e.
## Method 3: Using Apache Commons CSV
Apache Commons CSV is another powerful library that provides comprehensive CSV parsing capabilities with excellent support for different CSV formats and configurations.
### Setting Up Apache Commons CSV
Add the Maven dependency:
```xml
org.apache.commons
commons-csv
1.10.0
Reading CSV with Apache Commons CSV
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVRecord;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.List;
public class CSVReaderApache {
public static void main(String[] args) {
String csvFile = "data.Now, dEFAULT
. On top of that, println("Name: " + record. println("ID: " + record.Consider this: get("name"));
System. That said, get(0);
for (String columnName : header. getRecords();
// Process header
CSVRecord header = records.Because of that, out. out.On top of that, withTrim())) {
List records = csvParser. So print(columnName + " | ");
}
System. get("email"));
System.withIgnoreHeaderCase()
.Worth adding: out. getParser().getHeaderNames()) {
System.out.That's why println("Email: " + record. Because of that, out. get("id"));
System.out.Think about it: withFirstRecordAsHeader()
. Because of that, println();
// Process data rows
for (CSVRecord record : records) {
System. csv";
try (Reader reader = new FileReader(csvFile);
CSVParser csvParser = new CSVParser(reader, CSVFormat.println("---");
}
} catch (IOException e) {
e.
## Method 4: Advanced CSV Parsing with Custom Configuration
For complex CSV files with special requirements, you may need to customize parsing options:
```java
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVRecord;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class AdvancedCSVReader {
public static void main(String[] args) {
String csvFile = "complex_data.csv";
try (Reader reader = new FileReader(csvFile);
CSVParser csvParser = new CSVParser(reader, CSVFormat.Because of that, dEFAULT
. withDelimiter(';') // Different delimiter
.So withQuote('"') // Quote character
. withEscape('\\') // Escape character
.withIgnoreEmptyLines() // Ignore empty lines
.withAllowMissingColumnNames())) { // Allow missing columns
for (CSVRecord record : csvParser) {
System.out.
```java
System.out.println("Record number = " + record.getRecordNumber());
System.out.println("Parsed record = " + record);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
The getRecordNumber() method is helpful when you need to reference or debug specific rows, while record.toString() provides a quick snapshot of all parsed values. For more granular control, you can retrieve individual fields by column name or index:
String id = record.get("id");
String name = record.get("name");
String email = record.get("email");
If your CSV may contain missing columns, consider using record.isSet("email") or record.isMapped("email") before calling get. This prevents IllegalArgumentException when a column is absent from a particular row.
The advanced configuration shown here demonstrates how Apache Commons CSV can be tailored for real-world files. A semicolon delimiter, custom quotes, escape characters, empty-line handling, and optional header names are just a few examples. Once the format is defined correctly, the parser handles quoting, escaping, and record boundaries reliably.
Pulling it all together, Apache Commons CSV offers a powerful and flexible API for reading CSV files in Java. The basic parser is sufficient for simple files, while custom formats handle more complex requirements. By combining CSVFormat configuration, try-with-resources, and iteration over CSVRecord, developers can build reliable CSV-processing solutions with minimal boilerplate. Proper error handling and format selection are key to ensuring accurate data ingestion That's the part that actually makes a difference..
