Lectura de un archivo CSV

Introducción

En este laboratorio, aprenderemos cómo leer archivos CSV (Comma-Separated Values, Valores Separados por Comas) en Java. CSV es un formato de archivo común utilizado para almacenar datos tabulares, como hojas de cálculo o exportaciones de bases de datos. Cada línea en un archivo CSV representa una fila de datos, con columnas separadas por comas.

Exploraremos tres enfoques diferentes para leer archivos CSV en Java:

• Utilizando la clase BufferedReader del paquete java.io
• Utilizando la clase Scanner del paquete java.util
• Utilizando la biblioteca OpenCSV, una popular biblioteca de terceros para el procesamiento de archivos CSV

Al final de este laboratorio, podrás elegir el método más adecuado para leer archivos CSV en tus aplicaciones Java según tus requisitos específicos.

Skills Graph

Crear un archivo CSV de muestra y la estructura del proyecto

Antes de comenzar a leer archivos CSV, aseguremos que nuestro proyecto esté configurado correctamente. En este paso, examinaremos la estructura de nuestro archivo CSV y crearemos nuestra clase Java principal.

Comprender los archivos CSV

Un archivo CSV (Comma-Separated Values, Valores Separados por Comas) almacena datos tabulares en texto plano. Cada línea representa una fila, y las columnas están separadas por comas. Los archivos CSV se utilizan ampliamente para el intercambio de datos debido a su simplicidad y compatibilidad con muchas aplicaciones como Excel, Google Sheets y sistemas de bases de datos.

Examinar nuestro archivo CSV de muestra

Nuestro entorno de laboratorio ya incluye un archivo CSV de muestra en ~/project/sample.csv. Primero, echemos un vistazo a su contenido:

cat ~/project/sample.csv

Deberías ver la siguiente salida:

name,age,city
John,25,New York
Alice,30,Los Angeles
Bob,28,Chicago
Eve,22,Boston

Este archivo CSV contiene cuatro filas de datos (incluyendo la fila de encabezado) con información sobre personas, sus edades y ciudades.

Crear nuestra clase Java

Ahora, creemos una nueva clase Java llamada CSVReaderDemo.java en el directorio src que usaremos a lo largo de este laboratorio.

En VSCode, haz clic en el icono del Explorador en la barra lateral, navega hasta el directorio ~/project/src, haz clic derecho sobre él y selecciona "Nuevo archivo". Nombrar el archivo CSVReaderDemo.java.

Agrega la siguiente estructura básica al archivo:

public class CSVReaderDemo {
    public static void main(String[] args) {
        System.out.println("CSV Reader Demo");

        // We will add CSV reading code here in the next steps
    }
}

Compilémos y ejecutemos nuestra clase Java para verificar que todo esté configurado correctamente:

cd ~/project
javac -d . src/CSVReaderDemo.java
java CSVReaderDemo

Deberías ver la salida:

CSV Reader Demo

¡Genial! Ahora tenemos la estructura de nuestro proyecto lista. En los siguientes pasos, implementaremos diferentes métodos para leer nuestro archivo CSV.

Lectura de archivos CSV utilizando BufferedReader

En este paso, implementaremos nuestro primer enfoque para leer archivos CSV utilizando la clase BufferedReader del paquete java.io. Este es un método común y sencillo para leer archivos de texto en Java.

Comprender BufferedReader

BufferedReader es una clase que lee texto desde un flujo de entrada de caracteres, almacenando en buffer los caracteres para proporcionar una lectura eficiente de caracteres, matrices y líneas. Se puede especificar el tamaño del buffer o utilizar el tamaño predeterminado.

Implementar la lectura de CSV con BufferedReader

Actualicemos nuestro archivo CSVReaderDemo.java para leer el archivo CSV utilizando BufferedReader. Reemplace todo el contenido del archivo con el siguiente código:

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

public class CSVReaderDemo {
    public static void main(String[] args) {
        System.out.println("Reading CSV using BufferedReader");

        // Path to our CSV file
        String csvFile = "sample.csv";

        // Lists to store our data
        List<List<String>> data = new ArrayList<>();

        // Try-with-resources to ensure the reader gets closed automatically
        try (BufferedReader br = new BufferedReader(new FileReader(csvFile))) {
            String line;

            // Read each line from the file
            while ((line = br.readLine()) != null) {
                // Split the line by comma and convert to a List
                String[] values = line.split(",");
                List<String> lineData = Arrays.asList(values);

                // Add the line data to our main list
                data.add(lineData);
            }

            // Print the data we read
            System.out.println("\nData read from CSV file:");
            for (int i = 0; i < data.size(); i++) {
                List<String> row = data.get(i);
                System.out.println("Row " + i + ": " + String.join(", ", row));
            }

        } catch (IOException e) {
            System.err.println("Error reading the CSV file: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Compilémos y ejecutemos nuestro código actualizado:

cd ~/project
javac -d . src/CSVReaderDemo.java
java CSVReaderDemo

Deberías ver una salida similar a esta:

Reading CSV using BufferedReader

Data read from CSV file:
Row 0: name, age, city
Row 1: John, 25, New York
Row 2: Alice, 30, Los Angeles
Row 3: Bob, 28, Chicago
Row 4: Eve, 22, Boston

Explicación del código

1. Importamos las clases de Java necesarias para las operaciones de entrada/salida de archivos y las estructuras de datos.
2. Definimos la ruta a nuestro archivo CSV (sample.csv).
3. Creamos un List<List<String>> para almacenar nuestros datos CSV como una lista bidimensional.
4. Utilizamos un bloque try-with-resources para cerrar automáticamente el BufferedReader después de su uso.
5. Leemos cada línea del archivo con br.readLine().
6. Para cada línea, la dividimos por comas utilizando line.split(",") y la convertimos en una List.
7. Agregamos cada fila a nuestra lista principal de datos.
8. Finalmente, imprimimos los datos para verificar que los hemos leído correctamente.

El enfoque de BufferedReader es simple y eficiente para leer archivos de texto, incluyendo archivos CSV. Sin embargo, tiene limitaciones cuando se trata de formatos CSV más complejos, como campos que contienen comas o saltos de línea encerrados entre comillas.

En el siguiente paso, exploraremos otro enfoque utilizando la clase Scanner.

Lectura de archivos CSV utilizando Scanner

En este paso, implementaremos nuestro segundo enfoque para leer archivos CSV utilizando la clase Scanner del paquete java.util. La clase Scanner proporciona una forma conveniente de leer entrada formateada de diversas fuentes.

Comprender Scanner

La clase Scanner divide su entrada en tokens utilizando un patrón delimitador, que por defecto coincide con los espacios en blanco. Los tokens resultantes luego se pueden convertir en valores de diferentes tipos utilizando los diversos métodos next.

Implementar la lectura de CSV con Scanner

Actualicemos nuestro archivo CSVReaderDemo.java para leer el archivo CSV utilizando Scanner. Reemplace todo el contenido del archivo con el siguiente código:

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class CSVReaderDemo {
    public static void main(String[] args) {
        System.out.println("Reading CSV using Scanner");

        // Path to our CSV file
        String csvFile = "sample.csv";

        // Lists to store our data
        List<List<String>> data = new ArrayList<>();

        try (Scanner scanner = new Scanner(new File(csvFile))) {
            // Read each line from the file
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();

                // Split the line by comma and convert to a List
                String[] values = line.split(",");
                List<String> lineData = Arrays.asList(values);

                // Add the line data to our main list
                data.add(lineData);
            }

            // Print the data we read
            System.out.println("\nData read from CSV file:");
            for (int i = 0; i < data.size(); i++) {
                List<String> row = data.get(i);
                System.out.println("Row " + i + ": " + String.join(", ", row));
            }

        } catch (FileNotFoundException e) {
            System.err.println("CSV file not found: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Compilémos y ejecutemos nuestro código actualizado:

cd ~/project
javac -d . src/CSVReaderDemo.java
java CSVReaderDemo

Deberías ver una salida similar a esta:

Reading CSV using Scanner

Data read from CSV file:
Row 0: name, age, city
Row 1: John, 25, New York
Row 2: Alice, 30, Los Angeles
Row 3: Bob, 28, Chicago
Row 4: Eve, 22, Boston

Explicación del código

1. Importamos las clases de Java necesarias para las operaciones de archivos, Scanner y las estructuras de datos.
2. Definimos la ruta a nuestro archivo CSV (sample.csv).
3. Creamos un List<List<String>> para almacenar nuestros datos CSV como una lista bidimensional.
4. Utilizamos un bloque try-with-resources para cerrar automáticamente el Scanner después de su uso.
5. Leemos cada línea del archivo con scanner.nextLine() siempre y cuando scanner.hasNextLine() devuelva true.
6. Para cada línea, la dividimos por comas utilizando line.split(",") y la convertimos en una List.
7. Agregamos cada fila a nuestra lista principal de datos.
8. Finalmente, imprimimos los datos para verificar que los hemos leído correctamente.

El enfoque de Scanner es similar al enfoque de BufferedReader, pero proporciona métodos más convenientes para analizar diferentes tipos de datos. Sin embargo, al igual que BufferedReader, tiene limitaciones cuando se trata de formatos CSV complejos.

En el siguiente paso, exploraremos un enfoque más robusto utilizando la biblioteca OpenCSV, que maneja de manera más efectiva los formatos CSV complejos.

Lectura de archivos CSV utilizando la biblioteca OpenCSV

En este paso, implementaremos nuestro tercer enfoque para leer archivos CSV utilizando la biblioteca OpenCSV. OpenCSV es una biblioteca de terceros que ofrece capacidades sólidas de análisis (parsing) de archivos CSV, manejando escenarios complejos como campos que contienen comas o saltos de línea encerrados entre comillas.

Comprender OpenCSV

OpenCSV es una biblioteca de análisis de archivos CSV para Java que admite todas las variaciones básicas del formato CSV. A diferencia de los enfoques anteriores, OpenCSV maneja adecuadamente los campos entre comillas que contienen comas, saltos de línea y otros caracteres especiales que, de otro modo, harían que la simple división por comas fallara.

Configurar OpenCSV

Primero, descarguemos la biblioteca OpenCSV y sus dependencias:

cd ~/project
mkdir -p lib
curl -L -o lib/opencsv-5.7.1.jar https://repo1.maven.org/maven2/com/opencsv/opencsv/5.7.1/opencsv-5.7.1.jar
curl -L -o lib/commons-lang3-3.12.0.jar https://repo1.maven.org/maven2/org/apache/commons/commons-lang3/3.12.0/commons-lang3-3.12.0.jar
curl -L -o lib/commons-text-1.10.0.jar https://repo1.maven.org/maven2/org/apache/commons/commons-text/1.10.0/commons-text-1.10.0.jar
curl -L -o lib/commons-beanutils-1.9.4.jar https://repo1.maven.org/maven2/commons-beanutils/commons-beanutils/1.9.4/commons-beanutils-1.9.4.jar
curl -L -o lib/commons-collections-3.2.2.jar https://repo1.maven.org/maven2/commons-collections/commons-collections/3.2.2/commons-collections-3.2.2.jar
curl -L -o lib/commons-logging-1.2.jar https://repo1.maven.org/maven2/commons-logging/commons-logging/1.2/commons-logging-1.2.jar

Crear un archivo CSV más complejo

Creemos un archivo CSV más complejo que incluya campos entre comillas con comas:

echo 'name,description,price
"Laptop","High-performance laptop, with SSD",999.99
"Smartphone","Latest model, with dual camera",499.99
"Headphones","Noise-canceling, wireless",149.99' > ~/project/products.csv

Implementar la lectura de CSV con OpenCSV

Ahora, actualicemos nuestro archivo CSVReaderDemo.java para leer el archivo CSV utilizando OpenCSV. Reemplace todo el contenido del archivo con el siguiente código:

import com.opencsv.CSVReader;
import com.opencsv.exceptions.CsvValidationException;
import java.io.FileReader;
import java.io.IOException;

public class CSVReaderDemo {
    public static void main(String[] args) {
        System.out.println("Reading CSV using OpenCSV");

        // Path to our CSV file with complex data
        String csvFile = "products.csv";

        try (CSVReader reader = new CSVReader(new FileReader(csvFile))) {
            // Read and print the header
            String[] header = reader.readNext();
            if (header != null) {
                System.out.println("\nHeader: " + String.join(", ", header));
            }

            // Read and print each line
            String[] nextLine;
            int rowNumber = 1;

            System.out.println("\nData read from CSV file:");
            while ((nextLine = reader.readNext()) != null) {
                System.out.println("Row " + rowNumber + ":");
                for (int i = 0; i < nextLine.length; i++) {
                    System.out.println("  " + header[i] + ": " + nextLine[i]);
                }
                rowNumber++;
                System.out.println();
            }

        } catch (IOException | CsvValidationException e) {
            System.err.println("Error reading the CSV file: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Compilémos y ejecutemos nuestro código actualizado:

cd ~/project
javac -cp ".:lib/*" -d . src/CSVReaderDemo.java
java -cp ".:lib/*" CSVReaderDemo

Deberías ver una salida similar a esta:

Reading CSV using OpenCSV

Header: name, description, price

Data read from CSV file:
Row 1:
  name: Laptop
  description: High-performance laptop, with SSD
  price: 999.99

Row 2:
  name: Smartphone
  description: Latest model, with dual camera
  price: 499.99

Row 3:
  name: Headphones
  description: Noise-canceling, wireless
  price: 149.99

Explicación del código

1. Importamos las clases necesarias de la biblioteca OpenCSV y de la entrada/salida de Java.
2. Definimos la ruta a nuestro archivo CSV (products.csv).
3. Creamos un objeto CSVReader para leer el archivo CSV.
4. Leemos la fila de encabezado con reader.readNext() y la almacenamos para su uso posterior.
5. Luego, leemos cada fila subsiguiente con reader.readNext() en un bucle hasta que no haya más filas.
6. Para cada fila, imprimimos cada campo junto con su encabezado correspondiente.

La biblioteca OpenCSV maneja automáticamente el formato CSV complejo, analizando correctamente los campos con comas encerradas entre comillas. Esto la hace ideal para archivos CSV del mundo real que pueden contener datos complejos.

Ventajas de OpenCSV

OpenCSV ofrece varias ventajas sobre los enfoques básicos:

1. Maneja correctamente los campos entre comillas que contienen comas, saltos de línea y otros caracteres especiales.
2. Proporciona soporte integrado para leer en beans (objetos Java).
3. Admite características avanzadas como separadores personalizados, caracteres de comilla y caracteres de escape.
4. Maneja eficientemente archivos CSV grandes.

Para la mayoría de las aplicaciones del mundo real que trabajan con archivos CSV, se recomienda utilizar una biblioteca dedicada como OpenCSV.

Resumen

En este laboratorio (lab), exploramos tres enfoques diferentes para leer archivos CSV en Java:

1. Utilizando BufferedReader: Un enfoque sencillo que utiliza la biblioteca estándar de entrada/salida (I/O) de Java. Funciona bien para archivos CSV básicos, pero tiene limitaciones cuando se trata de formatos CSV complejos.
2. Utilizando Scanner: Otro enfoque que utiliza la biblioteca estándar de utilidades de Java. Al igual que BufferedReader, es adecuado para archivos CSV simples, pero carece de soporte para formatos CSV complejos.
3. Utilizando OpenCSV: Un enfoque robusto que utiliza una biblioteca de terceros diseñada específicamente para el procesamiento de archivos CSV. Maneja formatos CSV complejos, incluyendo campos entre comillas que contienen comas, saltos de línea y otros caracteres especiales.

Cada enfoque tiene sus fortalezas y casos de uso:

• BufferedReader y Scanner son buenas opciones para archivos CSV simples cuando se desea evitar dependencias externas.
• OpenCSV es la mejor opción para aplicaciones del mundo real que trabajan con archivos CSV potencialmente complejos.

Al entender estos diferentes enfoques, se puede elegir el método más adecuado según los requisitos específicos y la complejidad de los datos CSV.

Los archivos CSV se utilizan ampliamente en escenarios de procesamiento de datos, intercambio de datos e integración de datos. La capacidad de leer y procesar archivos CSV es una habilidad valiosa para los desarrolladores de Java, especialmente en aplicaciones centradas en datos e integraciones con otros sistemas.