Lecture d'un fichier CSV

JavaJavaBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire (lab), nous allons apprendre à lire des fichiers CSV (Comma-Separated Values, Valeurs séparées par des virgules) en Java. Le format CSV est un format de fichier courant utilisé pour stocker des données tabulaires telles que des feuilles de calcul ou des exports de base de données. Chaque ligne dans un fichier CSV représente une ligne de données, les colonnes étant séparées par des virgules.

Nous allons explorer trois approches différentes pour lire des fichiers CSV en Java :

  • En utilisant la classe BufferedReader du package java.io
  • En utilisant la classe Scanner du package java.util
  • En utilisant la bibliothèque OpenCSV, une bibliothèque tierce populaire pour le traitement des fichiers CSV

À la fin de ce laboratoire (lab), vous serez en mesure de choisir la méthode la plus appropriée pour lire des fichiers CSV dans vos applications Java en fonction de vos besoins spécifiques.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java(("Java")) -.-> java/FileandIOManagementGroup(["File and I/O Management"]) java(("Java")) -.-> java/ConcurrentandNetworkProgrammingGroup(["Concurrent and Network Programming"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java/DataStructuresGroup -.-> java/arrays("Arrays") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/arraylist("ArrayList") java/FileandIOManagementGroup -.-> java/files("Files") java/FileandIOManagementGroup -.-> java/create_write_files("Create/Write Files") java/FileandIOManagementGroup -.-> java/read_files("Read Files") java/FileandIOManagementGroup -.-> java/io("IO") java/ConcurrentandNetworkProgrammingGroup -.-> java/working("Working") subgraph Lab Skills java/arrays -.-> lab-117982{{"Lecture d'un fichier CSV"}} java/arraylist -.-> lab-117982{{"Lecture d'un fichier CSV"}} java/files -.-> lab-117982{{"Lecture d'un fichier CSV"}} java/create_write_files -.-> lab-117982{{"Lecture d'un fichier CSV"}} java/read_files -.-> lab-117982{{"Lecture d'un fichier CSV"}} java/io -.-> lab-117982{{"Lecture d'un fichier CSV"}} java/working -.-> lab-117982{{"Lecture d'un fichier CSV"}} end

Créer un fichier CSV d'exemple et la structure du projet

Avant de commencer à lire des fichiers CSV, assurons-nous que notre projet est correctement configuré. Dans cette étape, nous examinerons la structure de notre fichier CSV et créerons notre classe Java principale.

Comprendre les fichiers CSV

Un fichier CSV (Comma-Separated Values, Valeurs séparées par des virgules) stocke des données tabulaires au format texte brut. Chaque ligne représente une ligne de données, et les colonnes sont séparées par des virgules. Les fichiers CSV sont largement utilisés pour l'échange de données en raison de leur simplicité et de leur compatibilité avec de nombreuses applications telles qu'Excel, Google Sheets et les systèmes de bases de données.

Examiner notre fichier CSV d'exemple

Notre environnement de laboratoire (lab) inclut déjà un fichier CSV d'exemple à l'emplacement ~/project/sample.csv. Jetons d'abord un coup d'œil à son contenu :

cat ~/project/sample.csv

Vous devriez voir la sortie suivante :

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

Ce fichier CSV contient quatre lignes de données (y compris la ligne d'en-tête) avec des informations sur des personnes, leur âge et leur ville.

Créer notre classe Java

Maintenant, créons une nouvelle classe Java nommée CSVReaderDemo.java dans le répertoire src que nous utiliserons tout au long de ce laboratoire (lab).

Dans VSCode, cliquez sur l'icône de l'Explorateur dans la barre latérale, accédez au répertoire ~/project/src, cliquez droit sur celui-ci et sélectionnez "Nouveau fichier". Nommez le fichier CSVReaderDemo.java.

Ajoutez la structure de base suivante au fichier :

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

        // Nous ajouterons le code de lecture de CSV ici dans les prochaines étapes
    }
}
Créer un fichier Java

Compilons et exécutons notre classe Java pour vérifier que tout est correctement configuré :

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

Vous devriez voir la sortie suivante :

CSV Reader Demo

Parfait ! Maintenant, notre structure de projet est prête. Dans les prochaines étapes, nous implémenterons différentes méthodes pour lire notre fichier CSV.

Lecture de fichiers CSV avec BufferedReader

Dans cette étape, nous allons implémenter notre première approche pour lire des fichiers CSV en utilisant la classe BufferedReader du package java.io. C'est une méthode courante et simple pour lire des fichiers texte en Java.

Comprendre BufferedReader

BufferedReader est une classe qui lit le texte à partir d'un flux d'entrée de caractères, mettant en mémoire tampon les caractères pour permettre une lecture efficace de caractères, de tableaux et de lignes. La taille de la mémoire tampon peut être spécifiée, ou la taille par défaut peut être utilisée.

Implémentation de la lecture de CSV avec BufferedReader

Mettons à jour notre fichier CSVReaderDemo.java pour lire le fichier CSV en utilisant BufferedReader. Remplacez tout le contenu du fichier par le code suivant :

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();
        }
    }
}
Mettre à jour le fichier Java

Compilons et exécutons notre code mis à jour :

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

Vous devriez voir une sortie similaire à celle-ci :

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

Explication du code

  1. Nous importons les classes Java nécessaires pour les opérations d'entrée/sortie de fichiers et les structures de données.
  2. Nous définissons le chemin vers notre fichier CSV (sample.csv).
  3. Nous créons une List<List<String>> pour stocker nos données CSV sous forme de liste bidimensionnelle.
  4. Nous utilisons un bloc try-with-resources pour fermer automatiquement le BufferedReader après utilisation.
  5. Nous lisons chaque ligne du fichier avec br.readLine().
  6. Pour chaque ligne, nous la divisons par des virgules en utilisant line.split(",") et la convertissons en une List.
  7. Nous ajoutons chaque ligne à notre liste principale de données.
  8. Enfin, nous affichons les données pour vérifier que nous les avons lues correctement.

L'approche avec BufferedReader est simple et efficace pour lire des fichiers texte, y compris les fichiers CSV. Cependant, elle présente des limitations lorsqu'il s'agit de gérer des formats de CSV plus complexes, tels que des champs contenant des virgules ou des sauts de ligne entourés de guillemets.

Dans l'étape suivante, nous explorerons une autre approche en utilisant la classe Scanner.

Lecture de fichiers CSV avec Scanner

Dans cette étape, nous allons implémenter notre deuxième approche pour lire des fichiers CSV en utilisant la classe Scanner du package java.util. La classe Scanner offre un moyen pratique de lire des entrées formatées à partir de diverses sources.

Comprendre Scanner

La classe Scanner divise son entrée en jetons (tokens) en utilisant un modèle de délimiteur qui, par défaut, correspond aux espaces blancs. Les jetons obtenus peuvent ensuite être convertis en valeurs de différents types en utilisant les diverses méthodes next.

Implémentation de la lecture de CSV avec Scanner

Mettons à jour notre fichier CSVReaderDemo.java pour lire le fichier CSV en utilisant Scanner. Remplacez tout le contenu du fichier par le code suivant :

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();
        }
    }
}

Compilons et exécutons notre code mis à jour :

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

Vous devriez voir une sortie similaire à celle-ci :

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

Explication du code

  1. Nous importons les classes Java nécessaires pour les opérations sur les fichiers, Scanner et les structures de données.
  2. Nous définissons le chemin vers notre fichier CSV (sample.csv).
  3. Nous créons une List<List<String>> pour stocker nos données CSV sous forme de liste bidimensionnelle.
  4. Nous utilisons un bloc try-with-resources pour fermer automatiquement le Scanner après utilisation.
  5. Nous lisons chaque ligne du fichier avec scanner.nextLine() tant que scanner.hasNextLine() retourne true.
  6. Pour chaque ligne, nous la divisons par des virgules en utilisant line.split(",") et la convertissons en une List.
  7. Nous ajoutons chaque ligne à notre liste principale de données.
  8. Enfin, nous affichons les données pour vérifier que nous les avons lues correctement.

L'approche avec Scanner est similaire à celle avec BufferedReader, mais elle offre plus de méthodes pratiques pour analyser différents types de données. Cependant, comme BufferedReader, elle présente des limitations lorsqu'il s'agit de gérer des formats de CSV complexes.

Dans l'étape suivante, nous explorerons une approche plus robuste en utilisant la bibliothèque OpenCSV, qui gère plus efficacement les formats de CSV complexes.

Lecture de fichiers CSV avec la bibliothèque OpenCSV

Dans cette étape, nous allons implémenter notre troisième approche pour lire des fichiers CSV en utilisant la bibliothèque OpenCSV. OpenCSV est une bibliothèque tierce qui offre des capacités robustes de parsing (analyse) de CSV, gérant des scénarios complexes tels que des champs contenant des virgules ou des sauts de ligne entourés de guillemets.

Comprendre OpenCSV

OpenCSV est une bibliothèque de parsing de CSV pour Java qui prend en charge toutes les variations de base du format CSV. Contrairement aux approches précédentes, OpenCSV gère correctement les champs entre guillemets contenant des virgules, des sauts de ligne et autres caractères spéciaux qui autrement feraient échouer une simple division par virgules.

Configuration d'OpenCSV

Tout d'abord, téléchargeons la bibliothèque OpenCSV et ses dépendances :

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

Création d'un fichier CSV plus complexe

Créons un fichier CSV plus complexe qui inclut des champs entre guillemets contenant des virgules :

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

Implémentation de la lecture de CSV avec OpenCSV

Maintenant, mettons à jour notre fichier CSVReaderDemo.java pour lire le fichier CSV en utilisant OpenCSV. Remplacez tout le contenu du fichier par le code suivant :

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();
        }
    }
}

Compilons et exécutons notre code mis à jour :

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

Vous devriez voir une sortie similaire à celle-ci :

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

Explication du code

  1. Nous importons les classes nécessaires de la bibliothèque OpenCSV et de l'entrée/sortie Java.
  2. Nous définissons le chemin vers notre fichier CSV (products.csv).
  3. Nous créons un objet CSVReader pour lire le fichier CSV.
  4. Nous lisons la ligne d'en-tête avec reader.readNext() et la stockons pour une utilisation ultérieure.
  5. Nous lisons ensuite chaque ligne suivante avec reader.readNext() dans une boucle jusqu'à ce qu'il n'y ait plus de lignes.
  6. Pour chaque ligne, nous affichons chaque champ avec son en-tête correspondant.

La bibliothèque OpenCSV gère automatiquement le formatage complexe du CSV, analysant correctement les champs avec des virgules entre guillemets. Cela la rend idéale pour les fichiers CSV du monde réel qui peuvent contenir des données complexes.

Avantages d'OpenCSV

OpenCSV offre plusieurs avantages par rapport aux approches de base :

  1. Elle gère correctement les champs entre guillemets contenant des virgules, des sauts de ligne et autres caractères spéciaux.
  2. Elle propose un support intégré pour la lecture dans des beans (objets Java).
  3. Elle prend en charge des fonctionnalités avancées telles que des séparateurs personnalisés, des caractères de guillemets et des caractères d'échappement.
  4. Elle gère efficacement les grands fichiers CSV.

Pour la plupart des applications du monde réel qui traitent des fichiers CSV, l'utilisation d'une bibliothèque dédiée comme OpenCSV est l'approche recommandée.

Résumé

Dans ce laboratoire (lab), nous avons exploré trois approches différentes pour lire des fichiers CSV en Java :

  1. Utilisation de BufferedReader : Une approche simple utilisant la bibliothèque standard d'entrée/sortie (I/O) Java. Elle fonctionne bien pour les fichiers CSV de base, mais présente des limitations lorsqu'il s'agit de gérer des formats de CSV complexes.
  2. Utilisation de Scanner : Une autre approche utilisant la bibliothèque utilitaire standard Java. Comme BufferedReader, elle convient aux fichiers CSV simples, mais manque de prise en charge pour les formats de CSV complexes.
  3. Utilisation d'OpenCSV : Une approche robuste utilisant une bibliothèque tierce spécialement conçue pour le traitement de CSV. Elle gère les formats de CSV complexes, y compris les champs entre guillemets contenant des virgules, des sauts de ligne et autres caractères spéciaux.

Chaque approche a ses forces et ses cas d'utilisation :

  • BufferedReader et Scanner sont de bons choix pour les fichiers CSV simples lorsque vous souhaitez éviter les dépendances externes.
  • OpenCSV est le meilleur choix pour les applications du monde réel qui traitent des fichiers CSV potentiellement complexes.

En comprenant ces différentes approches, vous pouvez choisir la méthode la plus appropriée en fonction de vos besoins spécifiques et de la complexité de vos données CSV.

Les fichiers CSV sont largement utilisés dans les scénarios de traitement de données, d'échange de données et d'intégration de données. La capacité à lire et à traiter les fichiers CSV est une compétence précieuse pour les développeurs Java, en particulier dans les applications axées sur les données et les intégrations avec d'autres systèmes.