Im angegebenen Beispiel wird nur ein Objekt erstellt. Erstens findet JVM kein String-Objekt mit dem Wert „Welcome“ im String-Konstantenpool und erstellt daher ein neues Objekt. Danach wird die Zeichenfolge mit dem Wert „Willkommen“ im Pool gefunden. Es wird kein neues Objekt erstellt, sondern die Referenz auf dieselbe Instanz zurückgegeben. In diesem Artikel lernen wir etwas über Java-Strings.

Was sind Strings in Java?

Zeichenfolgen sind die Art von Objekten, die das Zeichen von Werten speichern können. In Java wird jedes Zeichen in 16 Bit gespeichert, d. h. unter Verwendung der UTF-16-Bit-Kodierung. Eine Zeichenfolge verhält sich genauso wie ein Zeichenarray in Java.

Beispiel:

String name = 'Geeks';>

String-Beispiel in Java

Unten finden Sie ein Beispiel für einen String in Java:

// Java Program to demonstrate // String public class StringExample {  // Main Function  public static void main(String args[])  {  String str = new String('example');  // creating Java string by new keyword  // this statement create two object i.e  // first the object is created in heap  // memory area and second the object is  // created in String constant pool.  System.out.println(str);  } }>

example>

Möglichkeiten zum Erstellen einer Zeichenfolge

Es gibt zwei Möglichkeiten, eine Zeichenfolge in Java zu erstellen:

• String-Literal
• Verwendung eines neuen Schlüsselworts

Syntax:

 = '';>

1. String-Literal

Um Java speichereffizienter zu machen (da keine neuen Objekte erstellt werden, wenn sie bereits im String-Konstantenpool vorhanden sind).

Beispiel:

String demoString = techcodeview.com;>

2. Neues Schlüsselwort verwenden

• String s = new String(Willkommen);
• In einem solchen Fall erstellt JVM ein neues String-Objekt im normalen Heap-Speicher (ohne Pool) und das Literal Welcome wird im String-Konstanten-Pool platziert. Die Variable s verweist auf das Objekt im Heap (kein Pool).

Beispiel:

String demoString = new String (techcodeview.com);>

Schnittstellen und Klassen in Strings in Java

CharBuffer : Diese Klasse implementiert die CharSequence-Schnittstelle. Diese Klasse wird verwendet, um die Verwendung von Zeichenpuffern anstelle von CharSequences zu ermöglichen. Ein Beispiel für eine solche Verwendung ist das reguläre Ausdruckspaket java.util.regex.

Liste als Array

Zeichenfolge : Es handelt sich um eine Zeichenfolge. In Java sind String-Objekte unveränderlich, d. h. eine Konstante, die nach ihrer Erstellung nicht mehr geändert werden kann.

CharSequence-Schnittstelle

Die CharSequence-Schnittstelle wird zur Darstellung der Zeichenfolge in Java verwendet.
Klassen, die mithilfe der CharSequence-Schnittstelle implementiert werden, werden unten erwähnt und bieten viele Funktionen wie Teilzeichenfolge, letztes Vorkommen, erstes Vorkommen, Verkettung, Toupper, Tolower usw.

1. Zeichenfolge
2. StringBuffer
3. StringBuilder

1. Zeichenfolge

String ist eine unveränderliche Klasse, das heißt eine Konstante und kann nach der Erstellung nicht mehr geändert werden. Wenn wir Änderungen vornehmen möchten, müssen wir ein neues Objekt erstellen, und selbst die von ihm bereitgestellten Funktionen wie Toupper, Tolower usw. geben alle ein neues Objekt zurück, das nicht geändert werden kann das Originalobjekt. Es ist automatisch threadsicher.

Syntax

String str= 'geeks';  or String str= new String('geeks')>

2. StringBuffer

StringBuffer ist eine Peer-Klasse von Zeichenfolge Es ist von Natur aus veränderbar und eine Thread-sichere Klasse. Wir können es verwenden, wenn wir eine Umgebung mit mehreren Threads und ein gemeinsames Objekt des String-Puffers haben, d. h. wenn es von mehreren Threads verwendet wird. Da es Thread-sicher ist und somit zusätzlichen Overhead verursacht, wird es hauptsächlich für Multithread-Programme verwendet.

Fuchs gegen Wolf

Syntax:

StringBuffer demoString = new StringBuffer('techcodeview.com');>

3. StringBuilder

StringBuilder stellt in Java eine Alternative zur String- und StringBuffer-Klasse dar, da sie eine veränderbare Zeichenfolge erstellt und nicht threadsicher ist. Es wird nur innerhalb des Threads verwendet, sodass kein zusätzlicher Overhead entsteht, und wird daher hauptsächlich für Single-Thread-Programme verwendet.

Syntax:

StringBuilder demoString = new StringBuilder(); demoString.append('GFG');>

StringTokenizer

StringTokenizer Die Klasse in Java wird verwendet, um eine Zeichenfolge in Token aufzuteilen.

Beispiel:

Ein StringTokenizer-Objekt behält intern eine aktuelle Position innerhalb der zu tokenisierenden Zeichenfolge bei. Bei einigen Vorgängen wird diese aktuelle Position über die verarbeiteten Zeichen hinaus verschoben. Ein Token wird zurückgegeben, indem ein Teilstring des Strings genommen wird, der zum Erstellen des StringTokenizer-Objekts verwendet wurde.

StringJoiner ist eine Klasse In java.util Paket, das verwendet wird, um eine Folge von Zeichen (Strings) zu erstellen, die durch ein Trennzeichen getrennt sind und optional mit einem bereitgestellten Präfix beginnen und mit einem bereitgestellten Suffix enden. Obwohl dies auch mit Hilfe der StringBuilder-Klasse möglich ist, um nach jeder Zeichenfolge ein Trennzeichen anzuhängen, bietet StringJoiner eine einfache Möglichkeit, dies zu tun, ohne viel Code schreiben zu müssen.

Syntax:

public StringJoiner(CharSequence delimiter)>

Oben haben wir gesehen, dass wir mit dem String-Literal einen String erstellen können.

String demoString =Willkommen;

Hier überprüft die JVM den String Constant Pool. Wenn die Zeichenfolge nicht vorhanden ist, wird eine neue Zeichenfolgeninstanz erstellt und in einem Pool abgelegt. Wenn die Zeichenfolge vorhanden ist, wird kein neues Objekt erstellt. Vielmehr wird der Verweis auf dieselbe Instanz zurückgegeben. Der Cache, der diese String-Instanzen speichert, wird als String-Konstanten-Pool oder String-Pool bezeichnet. In früheren Java-Versionen bis JDK 6 befand sich der String-Pool im PermGen-Bereich (Permanent Generation). Aber in JDK 7 wird es in den Haupt-Heap-Bereich verschoben.

Unveränderlicher String in Java

In Java sind String-Objekte unveränderlich. Unveränderlich bedeutet einfach unveränderlich oder unveränderlich. Sobald ein String-Objekt erstellt wurde, können seine Daten oder sein Status nicht mehr geändert werden, es wird jedoch ein neues String-Objekt erstellt.

Nachfolgend die Umsetzung des Themas:

// Java Program to demonstrate Immutable String in Java import java.io.*; class GFG {  public static void main(String[] args)  {  String s = 'Sachin';    // concat() method appends  // the string at the end  s.concat(' Tendulkar');    // This will print Sachin  // because strings are  // immutable objects  System.out.println(s);  } }>

Sachin>

Hier wird Sachin nicht verändert, sondern mit Sachin Tendulkar ein neues Objekt geschaffen. Aus diesem Grund wird eine Zeichenfolge als unveränderlich bezeichnet.

Wie Sie in der Abbildung sehen können, werden zwei Objekte erstellt, die Referenzvariable bezieht sich jedoch immer noch auf Sachin und nicht auf Sachin Tendulkar. Wenn wir es jedoch explizit der Referenzvariablen zuweisen, verweist es auf das Sachin Tendulkar-Objekt.

Zum Beispiel:

// Java Program to demonstrate Explicitly assigned strings import java.io.*; class GFG {  public static void main(String[] args)  {  String name = 'Sachin';  name = name.concat(' Tendulkar');  System.out.println(name);  } }>

Sachin Tendulkar>

Speicherzuteilung von String

Immer wenn ein String-Objekt als Literal erstellt wird, wird das Objekt im String-Konstantenpool erstellt. Dadurch kann JVM die Initialisierung von String-Literalen optimieren.

Beispiel:

String demoString = 'Geeks';>

Der String kann auch mit a deklariert werden neu Operator, d. h. dynamisch zugewiesen. Wenn Strings dynamisch zugewiesen werden, wird ihnen ein neuer Speicherort im Heap zugewiesen. Diese Zeichenfolge wird nicht zum String-Konstantenpool hinzugefügt.

Liste überspringen

Beispiel:

String demoString = new String('Geeks');>

Wenn Sie diese Zeichenfolge im Konstantenpool speichern möchten, müssen Sie sie internieren.

Beispiel:

String internedString = demoString.intern();  // this will add the string to string constant pool.>

Es wird bevorzugt, String-Literale zu verwenden, da JVM dadurch die Speicherzuweisung optimieren kann.

Ein Beispiel, das zeigt, wie ein String deklariert wird

// Java code to illustrate String import java.io.*; import java.lang.*; class Test {  public static void main(String[] args)  {  // Declare String without using new operator  String name = 'techcodeview.com';  // Prints the String.  System.out.println('String name = ' + name);  // Declare String using new operator  String newString = new String('techcodeview.com');  // Prints the String.  System.out.println('String newString = ' + newString);  } }>

String name = techcodeview.com String newString = techcodeview.com>

Notiz: Das String-Objekt wird im Heap-Bereich erstellt und Literale werden in einem speziellen Speicherbereich gespeichert, der als String-Konstantenpool bekannt ist.

Warum wurde der String-Pool von PermGen nach verschoben? Die normaler Heap-Bereich?

Der PermGen-Speicherplatz ist begrenzt, die Standardgröße beträgt nur 64 MB. Es gab ein Problem beim Erstellen und Speichern zu vieler String-Objekte im PermGen-Bereich. Aus diesem Grund wurde der String-Pool in einen größeren Heap-Bereich verschoben. Um Java speichereffizienter zu machen, wird das Konzept des String-Literals verwendet. Durch die Verwendung des Schlüsselworts „new“ erstellt die JVM ein neues String-Objekt im normalen Heap-Bereich, selbst wenn dasselbe String-Objekt im String-Pool vorhanden ist.

Zum Beispiel:

String demoString = new String('Bhubaneswar');>

Schauen wir uns das Konzept mit einem Java-Programm an und visualisieren die tatsächliche JVM-Speicherstruktur:

Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:

CSS-Ausrichtung von Bildern

// Java program and visualize the // actual JVM memory structure // mentioned in image class StringStorage {  public static void main(String args[])  {  // Declaring Strings  String s1 = 'TAT';  String s2 = 'TAT';  String s3 = new String('TAT');  String s4 = new String('TAT');  // Printing all the Strings  System.out.println(s1);  System.out.println(s2);  System.out.println(s3);  System.out.println(s4);  } }>

TAT TAT TAT TAT>

String-Pool in Java

Notiz: Alle Objekte in Java werden in einem Heap gespeichert. Die Referenzvariable bezieht sich auf das im Stapelbereich gespeicherte Objekt oder sie können in anderen Objekten enthalten sein, wodurch sie ebenfalls im Heap-Bereich platziert werden.

Beispiel 1:

// Construct String from subset of char array // Driver Class class GFG {  // main function  public static void main(String args[])  {  byte ascii[] = { 71, 70, 71 };  String firstString = new String(ascii);  System.out.println(firstString);  String secondString = new String(ascii, 1, 2);  System.out.println(secondString);  } }>

GFG FG>

Beispiel 2:

// Construct one string from another class GFG {  public static void main(String args[])  {  char characters[] = { 'G', 'f', 'g' };  String firstString = new String(characters);  String secondString = new String(firstString);  System.out.println(firstString);  System.out.println(secondString);  } }>

Gfg Gfg>

Häufig gestellte Fragen

1. Was sind Strings in Java?

Strings sind Objekttypen, die Zeichen als Elemente speichern können.

2. Warum sind String-Objekte in Java unveränderlich?

Weil Java das Konzept des String-Literals verwendet. Angenommen, es gibt 5 Referenzvariablen, die sich alle auf ein Sachin-Objekt beziehen. Wenn eine Referenzvariable den Wert des Objekts ändert, wird er von allen Referenzvariablen beeinflusst. Aus diesem Grund sind String-Objekte in Java unveränderlich.

3. Warum verwendet Java das Konzept des String-Literals?

Um Java speichereffizienter zu machen (da keine neuen Objekte erstellt werden, wenn sie bereits im String-Konstantenpool vorhanden sind).