LabEx
LoginBeitreten

Lesen einer CSV-Datei

JavaBeginner
Jetzt üben

Einführung

In diesem Lab werden wir lernen, wie man CSV (Comma-Separated Values, engl. für "durch Kommas getrennte Werte")-Dateien in Java liest. CSV ist ein gängiges Dateiformat, das zur Speicherung tabellarischer Daten wie Tabellenkalkulationen oder Datenbankexporte verwendet wird. Jede Zeile in einer CSV-Datei repräsentiert eine Datenzeile, wobei die Spalten durch Kommas getrennt sind.

Wir werden drei verschiedene Ansätze zum Lesen von CSV-Dateien in Java untersuchen:

  • Mit der BufferedReader-Klasse aus dem java.io-Paket
  • Mit der Scanner-Klasse aus dem java.util-Paket
  • Mit der OpenCSV-Bibliothek, einer beliebten Drittanbieter-Bibliothek für die CSV-Verarbeitung

Am Ende dieses Labs können Sie die am besten geeignete Methode zum Lesen von CSV-Dateien in Ihren Java-Anwendungen basierend auf Ihren spezifischen Anforderungen auswählen.

Erstellen einer Beispiel-CSV-Datei und des Projektstruktur

Bevor wir beginnen, CSV-Dateien zu lesen, stellen wir sicher, dass unser Projekt richtig eingerichtet ist. In diesem Schritt werden wir die Struktur unserer CSV-Datei untersuchen und unsere Haupt-Java-Klasse erstellen.

Grundlagen zu CSV-Dateien

Eine CSV (Comma-Separated Values, deutsch: "durch Kommas getrennte Werte")-Datei speichert tabellarische Daten im Klartext. Jede Zeile repräsentiert eine Zeile der Tabelle, und die Spalten werden durch Kommas getrennt. CSV-Dateien werden aufgrund ihrer Einfachheit und Kompatibilität mit vielen Anwendungen wie Excel, Google Sheets und Datenbanksystemen häufig für den Datenaustausch verwendet.

Untersuchung unserer Beispiel-CSV-Datei

Unsere Lab-Umgebung enthält bereits eine Beispiel-CSV-Datei unter ~/project/sample.csv. Schauen wir uns zunächst den Inhalt an:

cat ~/project/sample.csv

Sie sollten die folgende Ausgabe sehen:

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

Diese CSV-Datei enthält vier Datenzeilen (einschließlich der Kopfzeile) mit Informationen über Personen, ihre Alter und Städte.

Erstellen unserer Java-Klasse

Jetzt erstellen wir eine neue Java-Klasse namens CSVReaderDemo.java im src-Verzeichnis, die wir während dieses Labs verwenden werden.

In VSCode klicken Sie auf das Explorer-Symbol in der Seitenleiste, navigieren Sie zum Verzeichnis ~/project/src, klicken Sie mit der rechten Maustaste darauf und wählen Sie "Neue Datei". Benennen Sie die Datei CSVReaderDemo.java.

Fügen Sie der Datei die folgende Grundstruktur hinzu:

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

        // Wir werden in den nächsten Schritten den Code zum Lesen der CSV-Datei hinzufügen
    }
}

Create Java File

Lassen Sie uns unsere Java-Klasse kompilieren und ausführen, um zu überprüfen, ob alles richtig eingerichtet ist:

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

Sie sollten die folgende Ausgabe sehen:

CSV Reader Demo

Toll! Jetzt ist unsere Projektstruktur fertig. In den nächsten Schritten werden wir verschiedene Methoden implementieren, um unsere CSV-Datei zu lesen.

Lesen von CSV-Dateien mit BufferedReader

In diesem Schritt werden wir unseren ersten Ansatz zum Lesen von CSV-Dateien implementieren, indem wir die BufferedReader-Klasse aus dem java.io-Paket verwenden. Dies ist eine gängige und einfache Methode zum Lesen von Textdateien in Java.

Grundlagen zu BufferedReader

BufferedReader ist eine Klasse, die Text von einem Zeichen-Eingabestrom liest und Zeichen puffert, um ein effizientes Lesen von Zeichen, Arrays und Zeilen zu ermöglichen. Die Puffergröße kann angegeben werden, oder die Standardgröße kann verwendet werden.

Implementierung des CSV-Lesens mit BufferedReader

Lassen Sie uns die Datei CSVReaderDemo.java aktualisieren, um die CSV-Datei mit BufferedReader zu lesen. Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:

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

Update Java File

Lassen Sie uns unseren aktualisierten Code kompilieren und ausführen:

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

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Erklärung des Codes

  1. Wir importieren die notwendigen Java-Klassen für Datei-E/A-Operationen und Datenstrukturen.
  2. Wir definieren den Pfad zu unserer CSV-Datei (sample.csv).
  3. Wir erstellen eine List<List<String>>, um unsere CSV-Daten als zweidimensionale Liste zu speichern.
  4. Wir verwenden einen try-with-resources-Block, um den BufferedReader automatisch nach der Verwendung zu schließen.
  5. Wir lesen jede Zeile aus der Datei mit br.readLine().
  6. Für jede Zeile teilen wir sie anhand von Kommas mit line.split(",") auf und wandeln sie in eine List um.
  7. Wir fügen jede Zeile zu unserer Hauptliste der Daten hinzu.
  8. Schließlich geben wir die Daten aus, um zu überprüfen, ob wir sie korrekt gelesen haben.

Der BufferedReader-Ansatz ist einfach und effizient für das Lesen von Textdateien, einschließlich CSV-Dateien. Allerdings hat er Einschränkungen, wenn es um komplexere CSV-Formatierungen geht, wie z. B. Felder, die Kommas enthalten oder Zeilenumbrüche in Anführungszeichen eingeschlossen sind.

Im nächsten Schritt werden wir einen anderen Ansatz mit der Scanner-Klasse untersuchen.

Lesen von CSV-Dateien mit Scanner

In diesem Schritt werden wir unseren zweiten Ansatz zum Lesen von CSV-Dateien implementieren, indem wir die Scanner-Klasse aus dem java.util-Paket verwenden. Die Scanner-Klasse bietet eine bequeme Möglichkeit, formatierten Input aus verschiedenen Quellen zu lesen.

Grundlagen zu Scanner

Die Scanner-Klasse teilt ihren Input in Token auf, indem sie ein Trennzeichenmuster verwendet, das standardmäßig Leerzeichen erkennt. Die resultierenden Token können dann mit verschiedenen next-Methoden in Werte verschiedener Typen umgewandelt werden.

Implementierung des CSV-Lesens mit Scanner

Lassen Sie uns die Datei CSVReaderDemo.java aktualisieren, um die CSV-Datei mit Scanner zu lesen. Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:

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

Lassen Sie uns unseren aktualisierten Code kompilieren und ausführen:

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

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Erklärung des Codes

  1. Wir importieren die notwendigen Java-Klassen für Dateioperationen, Scanner und Datenstrukturen.
  2. Wir definieren den Pfad zu unserer CSV-Datei (sample.csv).
  3. Wir erstellen eine List<List<String>>, um unsere CSV-Daten als zweidimensionale Liste zu speichern.
  4. Wir verwenden einen try-with-resources-Block, um den Scanner automatisch nach der Verwendung zu schließen.
  5. Wir lesen jede Zeile aus der Datei mit scanner.nextLine(), solange scanner.hasNextLine() true zurückgibt.
  6. Für jede Zeile teilen wir sie anhand von Kommas mit line.split(",") auf und wandeln sie in eine List um.
  7. Wir fügen jede Zeile zu unserer Hauptliste der Daten hinzu.
  8. Schließlich geben wir die Daten aus, um zu überprüfen, ob wir sie korrekt gelesen haben.

Der Scanner-Ansatz ähnelt dem BufferedReader-Ansatz, bietet aber mehr bequeme Methoden zum Parsen verschiedener Datentypen. Allerdings hat er wie BufferedReader Einschränkungen, wenn es um komplexe CSV-Formatierungen geht.

Im nächsten Schritt werden wir einen robusteren Ansatz mit der OpenCSV-Bibliothek untersuchen, die komplexe CSV-Formatierungen effektiver verarbeitet.

Lesen von CSV-Dateien mit der OpenCSV-Bibliothek

In diesem Schritt werden wir unseren dritten Ansatz zum Lesen von CSV-Dateien implementieren, indem wir die OpenCSV-Bibliothek verwenden. OpenCSV ist eine Drittanbieter-Bibliothek, die robuste CSV-Parsing-Fähigkeiten bietet und komplexe Szenarien wie Felder mit Kommas oder Zeilenumbrüchen in Anführungszeichen verarbeiten kann.

Grundlagen zu OpenCSV

OpenCSV ist eine CSV-Parser-Bibliothek für Java, die alle gängigen CSV-Formatvariationen unterstützt. Im Gegensatz zu den vorherigen Ansätzen behandelt OpenCSV korrekt Anführungszeichen umgebene Felder, die Kommas, Zeilenumbrüche und andere Sonderzeichen enthalten, die sonst einfache Komma-Trennungen stören würden.

Einrichten von OpenCSV

Zunächst laden wir die OpenCSV-Bibliothek und ihre Abhängigkeiten herunter:

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

Erstellen einer komplexeren CSV-Datei

Wir erstellen nun eine komplexere CSV-Datei, die Anführungszeichen umgebene Felder mit Kommas enthält:

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

Implementierung des CSV-Lesens mit OpenCSV

Jetzt aktualisieren wir die Datei CSVReaderDemo.java, um die CSV-Datei mit OpenCSV zu lesen. Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:

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

Lassen Sie uns unseren aktualisierten Code kompilieren und ausführen:

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

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Erklärung des Codes

  1. Wir importieren die notwendigen Klassen aus der OpenCSV-Bibliothek und Java I/O.
  2. Wir definieren den Pfad zu unserer CSV-Datei (products.csv).
  3. Wir erstellen ein CSVReader-Objekt, um die CSV-Datei zu lesen.
  4. Wir lesen die Kopfzeile mit reader.readNext() und speichern sie für die spätere Verwendung.
  5. Dann lesen wir jede nachfolgende Zeile mit reader.readNext() in einer Schleife, bis keine Zeilen mehr vorhanden sind.
  6. Für jede Zeile geben wir jedes Feld zusammen mit seinem entsprechenden Kopfzeilentitel aus.

Die OpenCSV-Bibliothek behandelt die komplexe CSV-Formatierung automatisch und parst Felder mit Anführungszeichen umgebenen Kommas korrekt. Dies macht es ideal für reale CSV-Dateien, die komplexe Daten enthalten können.

Vorteile von OpenCSV

OpenCSV bietet mehrere Vorteile gegenüber den grundlegenden Ansätzen:

  1. Es behandelt korrekt Anführungszeichen umgebene Felder, die Kommas, Zeilenumbrüche und andere Sonderzeichen enthalten.
  2. Es bietet integrierte Unterstützung für das Lesen in Java-Objekte (Beans).
  3. Es unterstützt erweiterte Funktionen wie benutzerdefinierte Trennzeichen, Anführungszeichen und Escape-Zeichen.
  4. Es verarbeitet große CSV-Dateien effizient.

Für die meisten realen Anwendungen, die mit CSV-Dateien umgehen, ist die Verwendung einer speziellen Bibliothek wie OpenCSV der empfohlene Ansatz.

Zusammenfassung

In diesem Lab haben wir drei verschiedene Ansätze zum Lesen von CSV-Dateien in Java untersucht:

  1. Verwendung von BufferedReader: Ein einfacher Ansatz, der die Standard-Java-I/O-Bibliothek nutzt. Er funktioniert gut für einfache CSV-Dateien, hat aber Einschränkungen bei der Verarbeitung komplexer CSV-Formatierungen.
  2. Verwendung von Scanner: Ein weiterer Ansatz, der die Standard-Java-Util-Bibliothek verwendet. Wie BufferedReader eignet er sich für einfache CSV-Dateien, bietet aber keine Unterstützung für komplexe CSV-Formatierungen.
  3. Verwendung von OpenCSV: Ein robuster Ansatz, der eine Drittanbieter-Bibliothek nutzt, die speziell für die Verarbeitung von CSV-Dateien entwickelt wurde. Sie kann komplexe CSV-Formatierungen verarbeiten, einschließlich Anführungszeichen umgebener Felder mit Kommas, Zeilenumbrüchen und anderen Sonderzeichen.

Jeder Ansatz hat seine Stärken und Anwendungsfälle:

  • BufferedReader und Scanner sind gute Wahl für einfache CSV-Dateien, wenn Sie externe Abhängigkeiten vermeiden möchten.
  • OpenCSV ist die beste Wahl für reale Anwendungen, die mit möglicherweise komplexen CSV-Dateien umgehen müssen.

Durch das Verständnis dieser verschiedenen Ansätze können Sie die am besten geeignete Methode basierend auf Ihren spezifischen Anforderungen und der Komplexität Ihrer CSV-Daten auswählen.

CSV-Dateien werden häufig in Szenarien der Datenverarbeitung, des Datenaustauschs und der Datenintegration eingesetzt. Die Fähigkeit, CSV-Dateien zu lesen und zu verarbeiten, ist eine wertvolle Fähigkeit für Java-Entwickler, insbesondere in datenorientierten Anwendungen und bei der Integration mit anderen Systemen.

Verwandt Java Kurse
Java für Anfänger

Java für Anfänger

java
Java-Programmierübungen

Java-Programmierübungen

java
Massenimport von Daten in den Kursplan

Massenimport von Daten in den Kursplan

java