Hilfsklassen für die Arbeit mit Strings in Java

1. StringTokenizerKlasse

Und nun noch ein paar weitere häufige Szenarien, bei denen es um die Arbeit mit Strings geht. Wie zerlegt man eine Saite in mehrere Teile? Dafür gibt es mehrere Möglichkeiten.

split()Methode

Die erste Möglichkeit, eine Zeichenfolge in mehrere Teile aufzuteilen, ist die Verwendung der split()Methode. Als Argument muss ein regulärer Ausdruck übergeben werden, der eine spezielle Trennzeichenfolge definiert. Was ein regulärer Ausdruck ist, erfahren Sie in der Java-Multithreading- Quest.

Beispiel:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

Einfach, aber manchmal ist dieser Ansatz übertrieben. Wenn viele Trennzeichen vorhanden sind (z. B. Leerzeichen, Zeilenumbrüche, Tabulatoren, Punkte), müssen Sie einen recht komplexen regulären Ausdruck erstellen. Es ist schwer zu lesen und daher schwer zu ändern.

StringTokenizerKlasse

Java verfügt über eine spezielle Klasse, deren gesamte Aufgabe darin besteht, einen String in Teilstrings aufzuteilen.

Diese Klasse verwendet keine regulären Ausdrücke: Stattdessen übergeben Sie einfach eine Zeichenfolge bestehend aus Trennzeichen. Der Vorteil dieses Ansatzes besteht darin, dass nicht die gesamte Saite auf einmal in Stücke zerlegt wird, sondern Schritt für Schritt von Anfang bis Ende vorgegangen wird.

Die Klasse verfügt über einen Konstruktor und zwei wichtige Methoden. Wir übergeben dem Konstruktor eine Zeichenfolge, die wir in Teile aufteilen, und eine Zeichenfolge, die aus einer Reihe von Trennzeichen besteht.

String nextToken()

boolean hasMoreTokens()

Diese Klasse erinnert irgendwie an die Scanner-Klasse, die ebenfalls über nextLine()und- hasNextLine()Methoden verfügt.

Mit diesem Befehl können Sie ein StringTokenizerObjekt erstellen:

StringTokenizer name = new StringTokenizer(string, delimiters);

Wo stringist die Zeichenfolge, die in Teile geteilt werden soll? Und delimitersist eine Zeichenfolge, und jedes Zeichen darin wird als Trennzeichen behandelt. Beispiel:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

Beachten Sie, dass jedes Zeichen in der Zeichenfolge, die als zweite Zeichenfolge an den StringTokenizerKonstruktor übergeben wird, als Trennzeichen betrachtet wird.

2. String.format()Methode und StringFormatterKlasse

Eine weitere interessante Methode der String-Klasse ist format().

Nehmen wir an, Sie haben verschiedene Variablen, in denen Daten gespeichert sind. Wie stellt man sie in einer Zeile auf dem Bildschirm dar? Wir haben zum Beispiel einige Daten (linke Spalte) und die gewünschte Ausgabe (rechte Spalte):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

Ihr Code wird wahrscheinlich etwa so aussehen:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

Ein solcher Code ist nicht sehr gut lesbar. Und wenn die Variablennamen länger wären, würde der Code noch schwieriger werden:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

Nicht sehr gut lesbar, oder?

Da dies jedoch in realen Programmen häufig vorkommt, möchte ich Ihnen eine Möglichkeit vorstellen, diesen Code einfacher und prägnanter zu schreiben.

String.format

Die String-Klasse verfügt über eine statische format()Methode: Sie ermöglicht die Angabe eines Musters zum Zusammenstellen einer Zeichenfolge mit Daten. Das allgemeine Erscheinungsbild des Befehls ist wie folgt:

String name = String.format(pattern, parameters);

Beispiel:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

Der format()erste Parameter der Methode ist eine Formatzeichenfolge, die den gesamten gewünschten Text sowie Sonderzeichen, sogenannte Formatbezeichner (z. B. %dund %s), an den Stellen enthält, an denen Sie Daten einfügen müssen.

Die format()Methode ersetzt diese %sund %dFormatspezifizierer durch die Parameter, die der Formatzeichenfolge in der Parameterliste folgen. Wenn wir einen String einfügen wollen, dann schreiben wir %s. Wenn wir eine Zahl einfügen möchten, lautet der Formatbezeichner %d. Beispiel:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

Hier ist eine kurze Liste von Formatspezifizierern, die innerhalb der Formatzeichenfolge verwendet werden können:

%s

%d

%f

%b

%c

%t

%%

Diese Spezifizierer geben den Datentyp an, es gibt aber auch Spezifizierer, die die Reihenfolge der Daten angeben. Um ein Argument anhand seiner Nummer zu erhalten (die Nummerierung beginnt bei eins), müssen Sie „ “ anstelle von „ “ schreiben . Beispiel:%1$d%d

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$derhält das dritte Argument, %2$derhält das zweite Argument und %derhält das allererste Argument. Die Formatspezifizierer %sund beziehen sich auf Argumente, unabhängig von Spezifizierern wie oder%d%3$d%2$s

3. String-Pool

StringPoolJede im Code als String-Literal angegebene Zeichenfolge wird während der Ausführung des Programms in einem Speicherbereich namens gespeichert . StringPoolist ein spezielles Array zum Speichern von Strings. Sein Zweck besteht darin, die String-Speicherung zu optimieren:

Erstens müssen die im Code angegebenen Zeichenfolgen irgendwo gespeichert werden, oder? Code besteht aus Befehlen, Daten (insbesondere große Zeichenfolgen) müssen jedoch getrennt vom Code im Speicher gespeichert werden. Im Code erscheinen nur Verweise auf Zeichenfolgenobjekte.

Zweitens müssen alle identischen Zeichenfolgenliterale nur einmal im Speicher gespeichert werden. Und genau so funktioniert es. Wenn Ihr Klassencode von der Java-Maschine geladen wird, werden alle Zeichenfolgenliterale hinzugefügt, sofern StringPoolsie noch nicht vorhanden sind. Wenn sie bereits vorhanden sind, verwenden wir einfach eine String-Referenz aus der StringPool.

Wenn Sie also mehreren StringVariablen in Ihrem Code dasselbe Literal zuweisen, enthalten diese Variablen dieselbe Referenz. Dem wird StringPoolnur einmal ein Literal hinzugefügt. In allen anderen Fällen erhält der Code einen Verweis auf die bereits in die Datei geladene Zeichenfolge StringPool.

So funktioniert es ungefähr:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

Aus diesem Grund speichern die Variablen aund dieselben Referenzen.b

intern()Methode

Und das Beste daran ist, dass Sie dem programmgesteuert jede beliebige Zeichenfolge hinzufügen können StringPool. Dazu müssen Sie lediglich die Methode Stringder Variablen aufrufen intern().

Die intern()Methode fügt die Zeichenfolge hinzu, StringPoolsofern sie noch nicht vorhanden ist, und gibt einen Verweis auf die Zeichenfolge in zurück StringPool.

StringPoolWenn mit der Methode zwei identische Zeichenfolgen hinzugefügt werden intern(), gibt die Methode dieselbe Referenz zurück. Dies kann zum Vergleichen von Zeichenfolgen anhand von Referenzen verwendet werden. Beispiel:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

Es ist unwahrscheinlich, dass Sie diese Methode oft anwenden, aber in Vorstellungsgesprächen wird gerne danach gefragt . Es ist also besser, davon zu wissen, als es nicht zu wissen.