how to read a csv file java

Everly

3 min read

·

18-01-2025

25

0

Share

Reading and processing Comma Separated Value (CSV) files is a common task in many Java applications. CSV files are a simple and widely used format for storing tabular data. This article will guide you through several methods to effectively read CSV files in Java, from using built-in functionalities to leveraging powerful libraries. We'll cover error handling and best practices to ensure your code is robust and efficient.

Method 1: Using BufferedReader and String Splitting (Basic Approach)

This is the most straightforward method, ideal for simple CSV files without complex formatting. It uses Java's built-in BufferedReader to read the file line by line and then splits each line based on the comma delimiter.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadCSV {

    public static void main(String[] args) {
        String csvFile = "data.csv"; // Replace with your CSV file path
        String line;
        String[] values;

        try (BufferedReader br = new BufferedReader(new FileReader(csvFile))) {
            while ((line = br.readLine()) != null) {
                values = line.split(","); // Simple comma splitting
                for (String value : values) {
                    System.out.print(value + " ");
                }
                System.out.println();
            }
        } catch (IOException e) {
            System.err.println("Error reading CSV file: " + e.getMessage());
        }
    }
}

Limitations: This method struggles with CSV files containing commas within fields (e.g., "field1, with comma", "field2"). It also lacks robust error handling for malformed CSV data.

Method 2: Handling Commas within Fields using Quotation Marks

To address the limitations of the basic method, we need to account for fields enclosed in quotation marks (" "). This improved approach handles quoted fields correctly.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ReadCSVImproved {

    public static void main(String[] args) {
        String csvFile = "data.csv"; // Replace with your CSV file path
        String line;
        List<String> values = new ArrayList<>();

        try (BufferedReader br = new BufferedReader(new FileReader(csvFile))) {
            while ((line = br.readLine()) != null) {
                values.clear();
                char[] chars = line.toCharArray();
                StringBuilder sb = new StringBuilder();
                boolean inQuote = false;

                for (char c : chars) {
                    if (c == '"') {
                        inQuote = !inQuote;
                    } else if (c == ',' && !inQuote) {
                        values.add(sb.toString());
                        sb.setLength(0); // Clear StringBuilder
                    } else {
                        sb.append(c);
                    }
                }
                values.add(sb.toString()); //Add the last value

                for (String value : values) {
                    System.out.print(value + " ");
                }
                System.out.println();
            }
        } catch (IOException e) {
            System.err.println("Error reading CSV file: " + e.getMessage());
        }
    }
}

This code uses a StringBuilder and carefully tracks whether it is inside a quoted field. It's more complex but handles quoted commas effectively. However, it still lacks sophisticated error handling for more complex scenarios.

Method 3: Using a Dedicated CSV Library (OpenCSV)

For more robust and efficient CSV processing, consider using a dedicated library like OpenCSV. OpenCSV provides a simple API to handle various CSV formats, including those with escaped characters and different delimiters.

import com.opencsv.CSVReader;
import com.opencsv.CSVReaderBuilder;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class ReadCSVOpenCSV {
    public static void main(String[] args) {
        String csvFile = "data.csv"; // Replace with your CSV file path

        try (Reader reader = new FileReader(csvFile);
             CSVReader csvReader = new CSVReaderBuilder(reader).withSkipLines(1).build()) { // Skip header row if needed

            String[] nextLine;
            while ((nextLine = csvReader.readNext()) != null) {
                for (String value : nextLine) {
                    System.out.print(value + " ");
                }
                System.out.println();
            }
        } catch (IOException e) {
            System.err.println("Error reading CSV file: " + e.getMessage());
        }
    }
}

Remember to include the OpenCSV dependency in your pom.xml (if using Maven):

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

OpenCSV offers superior handling of complex CSV formats and error management compared to manual parsing.

Choosing the Right Method

• Basic BufferedReader: Suitable for very simple CSV files without complexities.
• Improved BufferedReader: Handles quoted fields but still lacks robust error handling.
• OpenCSV Library: The recommended approach for most scenarios, offering robustness, flexibility, and efficiency. It's worth the effort to learn and use it for anything beyond the most trivial CSV files.

Remember to always handle potential IOExceptions appropriately and choose the method best suited to your CSV file's complexity and your application's requirements. Using a dedicated library like OpenCSV provides the best balance of efficiency and error handling for most real-world scenarios.