Wie man einen String in Java mit einem Trennzeichen in eine ArrayList aufteilt

Einführung

In der Java-Programmierung sind die Manipulation von Strings und die Arbeit mit Sammlungen wie ArrayList wesentliche Fähigkeiten. Dieses Tutorial führt Sie durch den Prozess des Aufteilens eines Strings in eine ArrayList unter Verwendung eines Trennzeichens in Java. Am Ende dieses Labors werden Sie verstehen, wie man Textdaten in handhabbare Teile zerlegt und diese in einer flexiblen Sammlung speichert, sodass Sie verschiedene Datenverarbeitungsaufgaben in Ihren Java-Anwendungen bewältigen können.

Strings und ArrayLists in Java verstehen

Bevor wir uns mit dem Aufteilen von Strings befassen, wollen wir die beiden Schlüsselkomponenten verstehen, mit denen wir in diesem Labor arbeiten werden.

Strings in Java

Ein String in Java ist eine Folge von Zeichen. Er ist eine der am häufigsten verwendeten Klassen in der Java-Programmierung. Strings sind unveränderlich (immutable), was bedeutet, dass ihre Werte nach der Erstellung nicht geändert werden können.

Zum Beispiel:

String greeting = "Hello, World!";

ArrayLists in Java

Eine ArrayList ist eine dynamisch erweiterbare Array-Implementierung in Java. Im Gegensatz zu regulären Arrays, die eine feste Größe haben, können ArrayLists dynamisch wachsen oder schrumpfen. Sie sind Teil des Java Collections Framework und bieten verschiedene Methoden zur Manipulation der gespeicherten Elemente.

Um ArrayList zu verwenden, müssen wir sie aus dem Paket java.util importieren:

import java.util.ArrayList;

Erstellen einer ArrayList:

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");

Lassen Sie uns nun eine neue Java-Datei erstellen, um mit diesen Konzepten zu arbeiten. Befolgen Sie diese Schritte:

1. Öffnen Sie die WebIDE in Ihrer LabEx-Umgebung
2. Navigieren Sie zum Projektverzeichnis (es sollte standardmäßig geöffnet sein)
3. Erstellen Sie eine neue Datei namens StringSplitDemo.java, indem Sie auf das Symbol "Neue Datei" im Editor klicken
4. Fügen Sie den folgenden Basicode hinzu, um eine einfache Java-Klasse zu erstellen:

public class StringSplitDemo {
    public static void main(String[] args) {
        // We will add our code here
        System.out.println("String Split Demo");
    }
}

5. Speichern Sie die Datei, indem Sie Strg+S drücken
6. Öffnen Sie das Terminal in der IDE (falls noch nicht geöffnet) und kompilieren Sie die Java-Datei:

javac StringSplitDemo.java

7. Führen Sie das Programm aus:

java StringSplitDemo

Sie sollten die Ausgabe sehen:

String Split Demo

Dies bestätigt, dass Ihre grundlegende Java-Einrichtung korrekt funktioniert. Im nächsten Schritt werden wir lernen, wie man einen String mit der split()-Methode aufteilt.

Strings mit der split()-Methode aufteilen

Java bietet eine eingebaute Methode namens split() in der String-Klasse, mit der wir einen String basierend auf einem Trennzeichen in Teile aufteilen können. Die Methode gibt ein Array von Strings zurück, das die durch das Trennzeichen geteilten Teilstrings enthält.

Die split()-Methode

Die split()-Methode nimmt einen regulären Ausdruck (regular expression) als Parameter und gibt ein Array von Teilstrings zurück:

String[] split(String regex)

Lassen Sie uns unsere Datei StringSplitDemo.java so modifizieren, dass sie Code enthält, der einen String aufteilt. Öffnen Sie die Datei im Editor und aktualisieren Sie sie wie folgt:

public class StringSplitDemo {
    public static void main(String[] args) {
        // Create a string with comma-separated values
        String csvData = "apple,banana,orange,grape,mango";
        System.out.println("Original string: " + csvData);

        // Split the string using comma as delimiter
        String[] fruits = csvData.split(",");

        // Print the resulting array
        System.out.println("\nAfter splitting:");
        System.out.println("Number of elements: " + fruits.length);

        // Display each element of the array
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("Element " + i + ": " + fruits[i]);
        }
    }
}

Speichern Sie die Datei und führen Sie das Programm aus:

javac StringSplitDemo.java
java StringSplitDemo

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original string: apple,banana,orange,grape,mango

After splitting:
Number of elements: 5
Element 0: apple
Element 1: banana
Element 2: orange
Element 3: grape
Element 4: mango

Dies zeigt, wie die split()-Methode den ursprünglichen String an jedem Komma teilt und jeden Teilstring in ein Array einfügt. Das Array fruits enthält nun fünf Elemente, die jeweils einen Fruchtname aus unserem ursprünglichen, durch Kommas getrennten String darstellen.

Im nächsten Schritt werden wir dieses Array in eine ArrayList konvertieren, um mehr Flexibilität bei der Manipulation der Daten zu haben.

Einen aufgeteilten String in eine ArrayList konvertieren

Nachdem wir unseren String in ein Array aufgeteilt haben, wollen wir ihn in eine ArrayList konvertieren. ArrayLists bieten mehr Flexibilität als Arrays, einschließlich dynamischer Größenanpassung und praktischer Methoden zum Hinzufügen, Entfernen und Bearbeiten von Elementen.

Konvertieren eines Arrays in eine ArrayList

Es gibt verschiedene Möglichkeiten, ein Array in Java in eine ArrayList zu konvertieren:

1. Verwendung von Arrays.asList() und dem ArrayList-Konstruktor
2. Verwendung einer Schleife, um jedes Element einzeln hinzuzufügen
3. Verwendung der Java 8 Stream API

Lassen Sie uns unsere Datei StringSplitDemo.java aktualisieren, um die Konvertierung in eine ArrayList einzubeziehen. Wir müssen die notwendigen Klassen aus dem Paket java.util importieren:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StringSplitDemo {
    public static void main(String[] args) {
        // Create a string with comma-separated values
        String csvData = "apple,banana,orange,grape,mango";
        System.out.println("Original string: " + csvData);

        // Split the string using comma as delimiter
        String[] fruits = csvData.split(",");

        // Print the resulting array
        System.out.println("\nAfter splitting into array:");
        System.out.println("Number of elements: " + fruits.length);

        // Display each element of the array
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("Array Element " + i + ": " + fruits[i]);
        }

        // Method 1: Convert to ArrayList using Arrays.asList() and the ArrayList constructor
        ArrayList<String> fruitList1 = new ArrayList<>(Arrays.asList(fruits));

        // Method 2: Convert to ArrayList using a loop
        ArrayList<String> fruitList2 = new ArrayList<>();
        for (String fruit : fruits) {
            fruitList2.add(fruit);
        }

        // Display the ArrayList created using Method 1
        System.out.println("\nAfter converting to ArrayList (Method 1):");
        System.out.println("Number of elements: " + fruitList1.size());

        for (int i = 0; i < fruitList1.size(); i++) {
            System.out.println("ArrayList Element " + i + ": " + fruitList1.get(i));
        }

        // Demonstrate adding a new element to the ArrayList
        fruitList1.add("pineapple");
        System.out.println("\nAfter adding a new element to ArrayList:");
        System.out.println("Number of elements: " + fruitList1.size());
        System.out.println("New element: " + fruitList1.get(fruitList1.size() - 1));
    }
}

Speichern Sie die Datei und führen Sie das Programm aus:

javac StringSplitDemo.java
java StringSplitDemo

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original string: apple,banana,orange,grape,mango

After splitting into array:
Number of elements: 5
Array Element 0: apple
Array Element 1: banana
Array Element 2: orange
Array Element 3: grape
Array Element 4: mango

After converting to ArrayList (Method 1):
Number of elements: 5
ArrayList Element 0: apple
ArrayList Element 1: banana
ArrayList Element 2: orange
ArrayList Element 3: grape
ArrayList Element 4: mango

After adding a new element to ArrayList:
Number of elements: 6
New element: pineapple

Dieses Beispiel zeigt, wie man ein String-Array in eine ArrayList konvertiert und einen der Vorteile der Verwendung einer ArrayList aufzeigt: die Möglichkeit, der Sammlung einfach neue Elemente hinzuzufügen.

Beachten Sie die Unterschiede zwischen Arrays und ArrayLists:

• Arrays haben eine feste Größe, während ArrayLists dynamisch wachsen können
• ArrayLists bieten Methoden wie add(), remove() und get() zur Manipulation von Elementen
• ArrayLists können nur Objekte speichern, keine primitiven Typen (obwohl Java die Konvertierung automatisch mit Autoboxing (autoboxing) handhabt)

Im nächsten Schritt werden wir verschiedene Trennzeichen zum Aufteilen von Strings untersuchen.

Arbeiten mit verschiedenen Trennzeichen

In den vorherigen Schritten haben wir ein Komma als Trennzeichen verwendet, um den String aufzuteilen. Die split()-Methode akzeptiert jedoch jeden regulären Ausdruck (regular expression) als Trennzeichen, wodurch wir Strings basierend auf verschiedenen Mustern aufteilen können.

Lassen Sie uns eine neue Java-Datei erstellen, um mit verschiedenen Trennzeichen zu experimentieren. Erstellen Sie eine Datei namens DelimiterDemo.java mit folgendem Inhalt:

import java.util.ArrayList;
import java.util.Arrays;

public class DelimiterDemo {
    public static void main(String[] args) {
        // 1. Splitting by a single character
        String commaString = "red,green,blue,yellow";
        ArrayList<String> colors = new ArrayList<>(Arrays.asList(commaString.split(",")));

        System.out.println("1. Splitting by comma:");
        for (String color : colors) {
            System.out.println("  " + color);
        }

        // 2. Splitting by space
        String spaceString = "Java Python C++ JavaScript Ruby";
        ArrayList<String> languages = new ArrayList<>(Arrays.asList(spaceString.split(" ")));

        System.out.println("\n2. Splitting by space:");
        for (String language : languages) {
            System.out.println("  " + language);
        }

        // 3. Splitting by multiple characters
        String pipeColonString = "name|John:age|30:city|New York";
        ArrayList<String> personData = new ArrayList<>(Arrays.asList(pipeColonString.split("[|:]")));

        System.out.println("\n3. Splitting by multiple characters (| or :):");
        for (String data : personData) {
            System.out.println("  " + data);
        }

        // 4. Splitting by digits
        String digitsString = "apple123banana456cherry";
        ArrayList<String> fruits = new ArrayList<>(Arrays.asList(digitsString.split("\\d+")));

        System.out.println("\n4. Splitting by digits:");
        for (String fruit : fruits) {
            System.out.println("  " + fruit);
        }

        // 5. Limiting the number of splits
        String limitString = "one-two-three-four-five";
        ArrayList<String> limitedParts = new ArrayList<>(Arrays.asList(limitString.split("-", 3)));

        System.out.println("\n5. Limiting the number of splits (limit=3):");
        for (String part : limitedParts) {
            System.out.println("  " + part);
        }
    }
}

Speichern Sie die Datei und führen Sie das Programm aus:

javac DelimiterDemo.java
java DelimiterDemo

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

1. Splitting by comma:
  red
  green
  blue
  yellow

2. Splitting by space:
  Java
  Python
  C++
  JavaScript
  Ruby

3. Splitting by multiple characters (| or :):
  name
  John
  age
  30
  city
  New York

4. Splitting by digits:
  apple
  banana
  cherry

5. Limiting the number of splits (limit=3):
  one
  two
  three-four-five

Verstehen verschiedener Trennzeichen-Typen

1. Einzelzeichen-Trennzeichen (Single Character Delimiter): Die einfachste Form, wie Kommas oder Leerzeichen.

   string.split(",")

2. Zeichenklassen-Trennzeichen (Character Class Delimiters): Aufteilen nach einem beliebigen Zeichen in einem Satz.

   string.split("[|:]")  // Aufteilen nach '|' oder ':'

3. Reguläre-Ausdruck-Trennzeichen (Regular Expression Delimiters): Für komplexere Muster.

   string.split("\\d+")  // Aufteilen nach einer oder mehreren Ziffern

4. Begrenzen der Aufteilungen (Limiting Splits): Der zweite Parameter begrenzt die Anzahl der Aufteilungen.

   string.split("-", 3)  // Max. 3 Teile (2 Aufteilungen)

Sonderzeichen in regulären Ausdrücken

Bei der Verwendung von regulären Ausdrücken als Trennzeichen haben bestimmte Zeichen Sonderbedeutungen und müssen mit einem Backslash (\) maskiert werden. Da der Backslash selbst in Java-Strings maskiert werden muss, erhalten Sie doppelte Backslashes (\\).

Einige häufige Sonderzeichen:

• \d - Entspricht einer beliebigen Ziffer (in Java als \\d schreiben)
• \s - Entspricht einem beliebigen Leerzeichen (in Java als \\s schreiben)
• . - Entspricht einem beliebigen Zeichen (in Java als \\. schreiben)
• +, *, ? - Quantifizierer (in Java als \\+, \\*, \\? schreiben)

Diese Beispiele demonstrieren die Vielseitigkeit der split()-Methode für die Handhabung verschiedener String-Formate und Anforderungen in Ihren Java-Anwendungen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man Strings in Java mit Trennzeichen in ArrayLists aufteilt. Sie haben praktische Erfahrung gesammelt mit:

• Verständnis und Arbeit mit Strings und ArrayLists in Java
• Verwendung der split()-Methode zum Aufteilen von Strings basierend auf Trennzeichen
• Konvertieren von String-Arrays in ArrayLists für flexiblere Datenmanipulation
• Arbeiten mit verschiedenen Arten von Trennzeichen, einschließlich einzelner Zeichen, Zeichenklassen und regulären Ausdrücken
• Steuerung des Aufteilungsprozesses mit Limit-Parametern

Diese String-Manipulationsfähigkeiten sind grundlegend in der Java-Programmierung und helfen Ihnen in verschiedenen Szenarien, einschließlich des Parsens von Daten aus Dateien, der Verarbeitung von Benutzereingaben und der Arbeit mit strukturierten Textformaten wie CSV oder JSON.

Durch die Kombination der Leistungsfähigkeit von regulären Ausdrücken mit Java-Sammlungen wie ArrayList können Sie String-Daten effizient verarbeiten und transformieren, um die Anforderungen Ihrer Anwendungen zu erfüllen.