Allgemeine Zeichenfolgenoperationen in Java

1. Einleitung

String-basierte Werte und Operationen sind in der täglichen Entwicklung weit verbreitet, und jeder Java-Entwickler muss in der Lage sein, damit umzugehen.

In diesem Tutorial stellen wir einen kurzen Spickzettel mit allgemeinen String- Operationen zur Verfügung.

Außerdem werden wir die Unterschiede zwischen equals und "==" sowie zwischen StringUtils # isBlank und # isEmpty beleuchten.

2. Ein Zeichen in einen String umwandeln

Ein Zeichen steht für ein Zeichen in Java. In den meisten Fällen benötigen wir jedoch einen String.

Also lasst uns mit der Transformation beginnen char s in String s :

String toStringWithConcatenation(final char c) { return String.valueOf(c); }

3. Anhängen von Zeichenfolgen

Eine weitere häufig benötigte Operation ist das Anhängen von Zeichenfolgen mit anderen Werten, z. B. einem Zeichen :

String appendWithConcatenation(final String prefix, final char c) { return prefix + c; }

Wir können andere Grundtypen mit einem anhängen String auch :

String appendWithStringBuilder(final String prefix, final char c) { return new StringBuilder(prefix).append(c).toString(); }

4. Einen Charakter anhand des Index ermitteln

Wenn wir ein Zeichen aus einer Zeichenfolge extrahieren müssen, bietet die API alles, was wir wollen:

char getCharacterByIndex(final String text, final int index) { return text.charAt(index); }

Da ein String ein char [] als Hintergrunddatenstruktur verwendet, beginnt der Index bei Null .

5. Umgang mit ASCII-Werten

Wir können leicht zwischen einem Zeichen und seiner numerischen Darstellung (ASCII) wechseln, indem wir Folgendes umwandeln:

int asciiValue(final char character) { return (int) character; } char fromAsciiValue(final int value) { Assert.isTrue(value >= 0 && value < 65536, "value is not a valid character"); return (char) value; }

Da ein int 4 vorzeichenlose Bytes und ein char 2 vorzeichenlose Bytes ist, müssen wir natürlich überprüfen, ob wir mit legalen Zeichenwerten arbeiten.

6. Alle Leerzeichen entfernen

Manchmal müssen wir einige Zeichen loswerden, meistens Leerzeichen. Eine gute Möglichkeit ist die Verwendung der replaceAll- Methode mit einem regulären Ausdruck:

String removeWhiteSpace(final String text) { return text.replaceAll("\\s+", ""); }

7. Verbinden von Sammlungen mit einem String

Ein weiterer häufiger Anwendungsfall ist, wenn wir eine Art Sammlung haben und daraus eine Zeichenfolge erstellen möchten:

 String fromCollection(final Collection collection) { return collection.stream().map(Objects::toString).collect(Collectors.joining(", ")); }

Beachten Sie, dass in Collectors.joining das Präfix oder das Suffix angegeben werden kann.

8. Teilen eines Strings

Auf der anderen Seite können wir eine Zeichenfolge mit der Trennmethode durch ein Trennzeichen teilen :

String[] splitByRegExPipe(final String text)  return text.split("\\

Auch hier verwenden wir einen regulären Ausdruck, diesmal um ihn durch eine Pipe zu teilen. Da wir ein Sonderzeichen verwenden wollen, müssen wir ihm entkommen.

Eine andere Möglichkeit ist die Verwendung der Pattern- Klasse:

String[] splitByPatternPipe(final String text) ")); 

9. Alle Zeichen als Stream verarbeiten

Bei detaillierter Verarbeitung können wir einen String in einen IntStream umwandeln :

IntStream getStream(final String text) { return text.chars(); }

10. Referenzgleichheit und Wertgleichheit

Strings sehen zwar wie ein primitiver Typ aus, sind es aber nicht.

Daher müssen wir zwischen Referenzgleichheit und Wertgleichheit unterscheiden. Referenzgleichheit impliziert immer Wertgleichheit, aber im Allgemeinen nicht umgekehrt. Die erste überprüfen wir mit der Operation '==' und die zweite mit der Methode equals :

@Test public void whenUsingEquals_thenWeCheckForTheSameValue() { assertTrue("Values are equal", new String("Test").equals("Test")); } @Test public void whenUsingEqualsSign_thenWeCheckForReferenceEquality() { assertFalse("References are not equal", new String("Test") == "Test"); }

Beachten Sie, dass Literale im Zeichenfolgenpool interniert sind. Daher kann der Compiler sie manchmal auf dieselbe Referenz optimieren:

@Test public void whenTheCompileCanBuildUpAString_thenWeGetTheSameReference() { assertTrue("Literals are concatenated by the compiler", "Test" == "Te"+"st"); }

11. Leere Zeichenfolge vs. leere Zeichenfolge

Es gibt einen subtilen Unterschied zwischen isBlank und isEmpty .

Eine Zeichenfolge ist leer, wenn sie null ist oder die Länge Null hat. Während eine Zeichenfolge leer ist, wenn sie null ist oder nur Leerzeichen enthält:

@Test public void whenUsingIsEmpty_thenWeCheckForNullorLengthZero() { assertTrue("null is empty", isEmpty(null)); assertTrue("nothing is empty", isEmpty("")); assertFalse("whitespace is not empty", isEmpty(" ")); assertFalse("whitespace is not empty", isEmpty("\n")); assertFalse("whitespace is not empty", isEmpty("\t")); assertFalse("text is not empty", isEmpty("Anything!")); } @Test public void whenUsingIsBlank_thenWeCheckForNullorOnlyContainingWhitespace() { assertTrue("null is blank", isBlank(null)); assertTrue("nothing is blank", isBlank("")); assertTrue("whitespace is blank", isBlank("\t\t \t\n\r")); assertFalse("test is not blank", isBlank("Anything!")); }

12. Schlussfolgerung

Strings sind ein Kerntyp in allen Arten von Anwendungen. In diesem Tutorial haben wir einige wichtige Operationen in gängigen Szenarien gelernt.

Darüber hinaus gaben wir Anweisungen zu detaillierteren Referenzen.

Schließlich ist der vollständige Code mit allen Beispielen in unserem GitHub-Repository verfügbar.