Java String

Tutorials
Java

Java String ist eine der am häufigsten verwendeten Klassen. Die Java String-Klasse ist im Paket java.lang definiert.

Java String

  • Grundsätzlich ist ein String eine Sequenz von Zeichen, aber es ist kein primitiver Typ.
  • Wenn wir in Java einen String erstellen, wird tatsächlich ein Objekt vom Typ String erstellt.
  • String ist ein unveränderliches Objekt, das bedeutet, dass es nach seiner Erstellung nicht geändert werden kann.
  • String ist die einzige Klasse, in der die Überladung von Operatoren in Java unterstützt wird. Wir können zwei Strings mit dem + Operator verknüpfen. Zum Beispiel "a"+"b"="ab".
  • Java bietet zwei nützliche Klassen für die Manipulation von Zeichenketten – StringBuffer und StringBuilder.

Lass uns mehr über die Java String-Klasse erfahren.

Verschiedene Möglichkeiten, einen String zu erstellen

Es gibt viele Möglichkeiten, ein String-Objekt in Java zu erstellen, einige der beliebten sind unten aufgeführt.

  1. Verwendung von Zeichenfolgenliteralen

    Dies ist die häufigste Methode zur Erstellung von Zeichenfolgen. In diesem Fall wird ein Zeichenfolgenliteral mit doppelten Anführungszeichen eingeschlossen.

    String str = "abc";

    Wenn wir eine Zeichenfolge mit doppelten Anführungszeichen erstellen, sucht die JVM im String-Pool, ob eine andere Zeichenfolge mit dem gleichen Wert gespeichert ist. Wenn sie gefunden wird, gibt sie einfach die Referenz auf dieses Zeichenfolgenobjekt zurück, sonst erstellt sie ein neues Zeichenfolgenobjekt mit dem angegebenen Wert und speichert es im String-Pool.

  2. Verwendung des neuen Schlüsselworts

    Mit dem neuen Operator können wir ein String-Objekt erstellen, genau wie bei jeder normalen Java-Klasse. In der String-Klasse stehen mehrere Konstruktoren zur Verfügung, um einen String aus einem Zeichenarray, einem Byte-Array, einem StringBuffer und einem StringBuilder zu erhalten.

    String str  =  new String("abc");
char[] a = {'a', 'b', 'c'};
String str2  =  new String(a);

Vergleich von Java-Strings

Die String-Klasse bietet die Methoden equals() und equalsIgnoreCase() zum Vergleichen von zwei Strings. Diese Methoden vergleichen den Wert des Strings, um zu überprüfen, ob zwei Strings gleich sind oder nicht. Es wird true zurückgegeben, wenn zwei Strings gleich sind, und false, wenn nicht.

package com.journaldev.string.examples;

/**
 * Java String Example
 * 
 * @author pankaj
 *
 */
public class StringEqualExample {

	public static void main(String[] args) {
		// Erstellen von zwei String-Objekten
		String s1 = "abc";
		String s2 = "abc";
		String s3 = "def";
		String s4 = "ABC";
		
		System.out.println(s1.equals(s2));//true
		System.out.println(s2.equals(s3));//false
		
		System.out.println(s1.equals(s4));//false;
		System.out.println(s1.equalsIgnoreCase(s4));//true
	}

}

Die Ausgabe des obigen Programms ist:

true
false
false
true

Die String-Klasse implementiert das Comparable-Interface, das die Methoden compareTo() und compareToIgnoreCase() bereitstellt und zwei Zeichenketten lexikografisch vergleicht. Beide Zeichenketten werden für den Vergleich in Unicode-Werte umgewandelt und es wird ein Ganzzahlwert zurückgegeben, der größer, kleiner oder gleich Null sein kann. Wenn die Zeichenketten gleich sind, wird Null zurückgegeben, ansonsten wird entweder ein Wert größer oder kleiner als Null zurückgegeben.

package com.journaldev.examples;

/**
 * Java String compareTo Example
 * 
 * @author pankaj
 *
 */
public class StringCompareToExample {

	public static void main(String[] args) {
		
		String a1 = "abc";
		String a2 = "abc";
		String a3 = "def";
		String a4 = "ABC";
		
		System.out.println(a1.compareTo(a2));//0
		System.out.println(a2.compareTo(a3));//less than 0
		System.out.println(a1.compareTo(a4));//greater than 0
		System.out.println(a1.compareToIgnoreCase(a4));//0
	}

}

Die Ausgabe des obigen Programms ist:

0
-3
32
0

Bitte lesen Sie dies detaillierter unter String compareTo Beispiel.

Java String Methoden

Werfen wir einen Blick auf einige der beliebten Methoden der String-Klasse mit einem Beispielprogramm.

  1. split()

    Die Java String split() Methode wird verwendet, um den String mithilfe des angegebenen Ausdrucks zu teilen. Es gibt zwei Varianten der split() Methode.

    • split(String regex): Diese Methode teilt den String mithilfe des angegebenen Regex-Ausdrucks und gibt ein Array von Zeichenketten zurück.
    • split(String regex, int limit): Diese Methode teilt den String mithilfe des angegebenen Regex-Ausdrucks und gibt ein Array von Zeichenketten zurück, wobei das Element des Arrays jedoch durch das angegebene Limit begrenzt ist. Wenn das angegebene Limit 2 ist, gibt die Methode ein Array der Größe 2 zurück.
    package com.journaldev.examples;

/**
 * Java String split example
 * 
 * @author pankaj
 *
 */
public class StringSplitExample {

	public static void main(String[] args) {
		
		String s = "a/b/c/d";
		String[] a1 = s.split("/");
		System.out.println("String mit nur Regex teilen:");
		for (String string : a1) {
			System.out.println(string);
		}
		System.out.println("String mit Regex und Limit teilen:");
		String[] a2 = s.split("/", 2);
		for (String string : a2) {
			System.out.println(string);
		}
	}

}

    Ausgabe des obigen Programms:

    String mit nur Regex teilen:
a
b
c
d
String mit Regex und Limit teilen:
a
b/c/d

  2. contains(CharSequence s)

    Die Java String contains() Methode überprüft, ob ein String die angegebene Zeichenfolge enthält oder nicht. Diese Methode gibt true zurück, wenn der String die angegebene Zeichenfolge enthält, andernfalls false.

    package com.journaldev.examples;

/**
 * Java String contains() Beispiel
 * 
 * @author pankaj
 *
 */
public class StringContainsExample {

	public static void main(String[] args) {
		String s = "Hallo Welt";
		
		System.out.println(s.contains("W"));//true
		System.out.println(s.contains("X"));//false
	}

}

    Das Ergebnis des obigen Programms ist:

    true
false

  3. Länge()

    Die Java String length() Methode gibt die Länge des Strings zurück.

    package com.journaldev.examples;

/**
 * Java String length
 * 
 * @author pankaj
 *
 */
public class StringLengthExample {

	public static void main(String[] args) {
		
		String s1 = "abc";
		String s2 = "abcdef";
		String s3 = "abcdefghi";
		
		System.out.println(s1.length());//3
		System.out.println(s2.length());//6
		System.out.println(s3.length());//9

	}

}

  4. ersetzen()

    Die Java String replace() Methode wird verwendet, um einen bestimmten Teil eines Strings durch einen anderen String zu ersetzen. Es gibt vier Varianten der replace() Methode.

    • replace(char oldChar, char newChar): Diese Methode ersetzt alle Vorkommen von oldChar durch newChar im String.
    • replace(CharSequence target, CharSequence replacement): Diese Methode ersetzt jedes Ziel-Literal durch das Ersatz-Literal im String.
    • replaceAll(String regex, String replacement): Diese Methode ersetzt alle Vorkommen von Teilzeichenfolgen, die mit dem angegebenen Regex übereinstimmen, durch den angegebenen Ersatz im String.
    • replaceFirst(String regex, String replacement): Diese Methode ersetzt das erste Vorkommen der Teilzeichenfolge, die mit dem angegebenen Regex übereinstimmt, durch den angegebenen Ersatz im String.
    package com.journaldev.examples;

/**
 * Java String ersetzen
 * 
 * @author pankaj
 *
 */
public class StringReplaceExample {

	public static void main(String[] args) {
		
		//replace(char oldChar,  char newChar)
		String s = "Hallo Welt";
		s = s.replace('l', 'm');
		System.out.println("Nach dem Ersetzen von l durch m :");
		System.out.println(s);
		
		//replaceAll(String regex, String replacement)
		String s1 = "Hallo journaldev, Hallo pankaj";
		s1 = s1.replaceAll("Hallo", "Hi");
		System.out.println("Nach dem Ersetzen :");
		System.out.println(s1);
		
		//replaceFirst(String regex, String replacement) 
		String s2 = "Hallo Leute, Hallo Welt";
		s2 = s2.replaceFirst("Hallo", "Hi");
		System.out.println("Nach dem Ersetzen :");
		System.out.println(s2);

	}

}

    Die Ausgabe des obigen Programms lautet:

    Nach dem Ersetzen von l durch m :
Hemmo Wormd
Nach dem Ersetzen :
Hi journaldev, Hi pankaj
Nach dem Ersetzen :
Hi Leute, Hallo Welt

  5. format()

    Die Java Sting format() Methode wird verwendet, um den String zu formatieren. Es gibt zwei Varianten der Java String format() Methode.

    • format(Locale l, String format, Object… args): Diese Methode formatiert den String unter Verwendung der angegebenen Lokalisierung, des Stringformats und der Argumente.
    • format(String format, Object… args): Diese Methode formatiert den String unter Verwendung des angegebenen Stringformats und der Argumente.
    package com.journaldev.examples;

import java.util.Locale;

/**
 * Java String format
 * 
 * @author pankaj
 *
 */
public class StringFormatExample {

	public static void main(String[] args) {
		
		String s = "journaldev.com";
		// %s wird verwendet, um den String anzuhängen
		System.out.println(String.format("Das ist %s", s));
		
		// Verwendung der Lokalisierung als Locale.US
		System.out.println(String.format(Locale.US, "%f", 3.14));
	}
}

    Ausgabe des obigen Programms ist:

    Das ist journaldev.com
3.140000

  6. substring()

    Diese Methode gibt einen Teil des Strings basierend auf angegebenen Indizes zurück.

    package com.journaldev.examples;

/**
 * Java String substring
 *
 */
public class StringSubStringExample {

	public static void main(String[] args) {
		
		String s = "Das ist journaldev.com";
		s = s.substring(8,18);
		System.out.println(s);
	}
}

String Konkatenation

String-Konkatenation ist eine sehr grundlegende Operation in Java. Strings können durch den Gebrauch des „+“-Operators oder durch die Verwendung der concat()-Methode konkateniert werden.

package com.journaldev.examples;

/**
 * Java String concatenation
 * 
 * @author pankaj
 *
 */
public class StringConcatExample {

	public static void main(String[] args) {
		
		String s1 = "Hello";
		String s2 = "World";
		String s3 = s1 + s2;
		// Verwendung des +-Operators
		System.out.println("Using + operator: ");
		System.out.println(s3);
		
		// Verwendung der concat-Methode
		System.out.println("Using concat method: ");
		System.out.println(s1.concat(s2));

	}

}

Die Ausgabe des obigen Programms ist:

Using + operator: 
HelloWorld
Using concat method: 
HelloWorld

Überprüfen Sie diesen Beitrag für weitere Informationen zur String-Konkatenation in Java.

Java String Pool

Die Speicherverwaltung ist der wichtigste Aspekt jeder Programmiersprache. Die Speicherverwaltung für Strings in Java unterscheidet sich etwas von anderen Klassen. Um Java speichereffizienter zu machen, hat die JVM einen speziellen Speicherbereich für Strings namens String Constant Pool eingeführt. Wenn wir ein String-Literal erstellen, überprüft es, ob bereits ein identischer String im String Pool vorhanden ist oder nicht. Wenn er vorhanden ist, gibt es die Referenz des vorhandenen Strings im String Pool zurück. Schauen wir uns das folgende Beispielprogramm an.

package com.journaldev.examples;

/**
 * Java String Pool Example
 * 
 */
public class StringPoolExample {

	public static void main(String[] args) {
		
		String a = "abc";
		String b = "abc";
		String c = "def";
		
		//selbe Referenz
		if (a==b) {
			System.out.println("Both string refer to the same object");
		}
		
		//verschiedene Referenz
		if (a==c) {
			System.out.println("Both strings refer to the same object");
		}else {
			System.out.println("Both strings refer to the different object");
		}

	}

}

Die Ausgabe des obigen Programms lautet:

Both string refer to the same object
Both strings refer to the different object

Lesen Sie diesen Beitrag für mehr Informationen über den Java String Pool.

Methode intern()

Was passiert, wenn wir einen String mit demselben Wert wie im String Pool verwenden, aber mit dem new-Schlüsselwort erstellen? Können wir den String vom Heap-Speicher in den String Pool verschieben? Dafür wird die Methode intern() verwendet, die eine kanonische Repräsentation des String-Objekts zurückgibt. Wenn wir die intern() Methode auf ein String-Objekt aufrufen, das mit dem new-Schlüsselwort erstellt wurde, überprüft sie, ob bereits ein String mit demselben Wert im Pool vorhanden ist. Wenn ja, gibt sie die Referenz auf dieses String-Objekt aus dem Pool zurück. Wenn nicht, erstellt sie einen neuen String mit demselben Inhalt im Pool und gibt die Referenz zurück.

package com.journaldev.examples;

/**
 * Java String intern
 * 
 * @author pankaj
 *
 */
public class StringInternExample {

	public static void main(String[] args) {
		
		String s1 = "pankaj";
		String s2 = "pankaj";
		String s3 = new String("pankaj");
		
		System.out.println(s1==s2);//true
		System.out.println(s2==s3);//false
		
		String s4 = s3.intern();
		System.out.println(s1==s4);//true

	}

}

Schau dir diesen Beitrag an, um mehr über die Java String intern-Methode zu erfahren.

Vorteile der Unveränderlichkeit von Zeichenketten

Einige der Vorteile der Unveränderlichkeit der String-Klasse sind:

  1. String-Konstantenpool, spart daher Speicherplatz.
  2. Sicherheit, da sie nicht geändert werden kann.
  3. Thread-sicher
  4. Class Loading Security

Sieh dir diesen Beitrag für mehr Informationen über die Vorteile der Unveränderlichkeit von Strings an.

Java 8 String join()

A new static method join() has been added in String class in Java 8. This method returns a new String composed of copies of the CharSequence elements joined together with a copy of the specified delimiter. Let’s look at an example to understand it easily.

List<String> words = Arrays.asList(new String[]{"Hello", "World", "2019"});
String msg = String.join(" ", words);
System.out.println(msg);

Ausgabe: Hallo Welt 2019

Java 9 String Methoden

Es gibt zwei Methoden, die in der String-Klasse in der Java 9-Version hinzugefügt wurden. Es handelt sich um codePoints() und chars(). Beide dieser Methoden geben ein IntStream-Objekt zurück, auf dem wir einige Operationen durchführen können. Schauen wir uns diese Methoden schnell an.

String s = "abc";

s.codePoints().forEach(x -> System.out.println(x));

s.chars().forEach(x -> System.out.println(x));

Output:

97
98
99
97
98
99

Java 11 String-Klasse Neue Methoden

Es gibt viele neue Methoden, die in der String-Klasse in der Java 11-Version hinzugefügt wurden.

  • isBlank() – gibt true zurück, wenn der String leer ist oder nur Leerzeichen-Codepunkte enthält, sonst false.
  • lines() – gibt einen Stream von Zeilen zurück, die aus diesem String extrahiert wurden und durch Zeilentrennzeichen getrennt sind.
  • strip(), stripLeading(), stripTrailing() – zum Entfernen von führenden und nachfolgenden Leerzeichen aus dem String.
  • repeat() – gibt einen String zurück, dessen Wert die Konkatenation dieses Strings ist, der eine bestimmte Anzahl von Malen wiederholt wird.

Lassen Sie uns ein Beispielprogramm für diese Methoden betrachten.

package com.journaldev.strings;

import java.util.List;
import java.util.stream.Collectors;

/**
 * JDK 11 New Functions in String class
 * 
 * @author pankaj
 *
 */
public class JDK11StringFunctions {

	public static void main(String[] args) {
		// isBlank()
		String s = "abc";
		System.out.println(s.isBlank());
		s = "";
		System.out.println(s.isBlank());

		// lines()
		String s1 = "Hi\nHello\rHowdy";
		System.out.println(s1);
		List lines = s1.lines().collect(Collectors.toList());
		System.out.println(lines);

		// strip(), stripLeading(), stripTrailing()
		String s2 = "  Java,  \tPython\t ";
		System.out.println("#" + s2 + "#");
		System.out.println("#" + s2.strip() + "#");
		System.out.println("#" + s2.stripLeading() + "#");
		System.out.println("#" + s2.stripTrailing() + "#");

		// repeat()
		String s3 = "Hello\n";
		System.out.println(s3.repeat(3));
		s3 = "Co";
		System.out.println(s3.repeat(2));

	}

}

Ausgabe:

false
true
Hi
Hello
Howdy
[Hi, Hello, Howdy]
#  Java,  	Python	 #
#Java,  	Python#
#Java,  	Python	 #
#  Java,  	Python#
Hello
Hello
Hello

CoCo

Das ist alles über die Java-String-Klasse, ihre Methoden und Beispiele für die String-Manipulation.

Sie können weitere String-Beispiele aus unserem GitHub-Repository überprüfen.

Referenz: API-Dokumentation

Source:
https://www.digitalocean.com/community/tutorials/java-string