String

String: String-Konstante, die Länge der Zeichenkette ist unveränderlich. In Java ist String unveränderlich.

Die String-Klasse enthält die folgende Definition:

/** The value is used for character storage. */
private final char value[];

/** The offset is the first index of the storage that is used. */
private final int offset;

/** The count is the number of characters in the String. */
private final int count;

Das zum Speichern von Zeichen verwendete Array ist als final deklariert, daher kann es nur einmal zugewiesen werden und kann nicht erneut geändert werden.

StringBuffer（JDK1.0）

StringBuffer: String-Variable (synchronisiert, d. h. thread-sicher). Wenn Sie Zeichenketteninhalte häufig ändern müssen, ist es aus Effizienzgründen am besten, StringBuffer zu verwenden. Wenn Sie ihn in den Typ String konvertieren möchten, können Sie die toString()-Methode von StringBuffer aufrufen.

Java.lang.StringBufferEine threadsichere, veränderliche Zeichenfolge. Zu jedem Zeitpunkt enthält sie eine bestimmte Zeichenfolge, aber die Länge und der Inhalt der Folge können durch bestimmte Methodenaufrufe geändert werden. String-Puffer können sicher von mehreren Threads verwendet werden.

StringBufferDie wichtigsten Operationen darauf sind die append- und insert-Methoden, die überladen werden können, um jeden Datentyp zu akzeptieren. Jede Methode wandelt die gegebenen Daten effektiv in eine Zeichenkette um und hängt dann die Zeichen dieser Zeichenkette an den String-Puffer an oder fügt sie ein.

• Die append-Methode fügt diese Zeichen immer am Ende des Puffers hinzu;
• die insert-Methode fügt Zeichen an der angegebenen Stelle ein.

Zum Beispiel, wennzauf ein String-Puffer-Objekt verweist, dessen aktueller Inhaltstartist, dann wird dieser Methodenaufrufz.append("le")bewirken, dass der String-Puffer enthältstartle, undz.insert(4, "le")wird den String-Puffer so ändern, dass erstarlet enthält 。

StringBuilder（JDK5.0）

StringBuilder: String-Variable (nicht threadsicher). Intern wird ein StringBuilder-Objekt als Array variabler Länge behandelt, das eine Zeichenfolge enthält.

java.lang.StringBuilder ist eine veränderliche Zeichenfolge, die in JDK 5.0 neu hinzugefügt wurde. Diese Klasse bietet eine zu StringBuffer kompatible API, garantiert jedoch keine Synchronisation. Diese Klasse ist als einfacher Ersatz für StringBuffer gedacht und wird verwendet, wenn der String-Puffer von einem einzelnen Thread genutzt wird (diese Situation ist sehr häufig).

Seine Konstruktoren sind wie folgt:

In den meisten Fällen gilt:StringBuilder > StringBuffer. Das liegt hauptsächlich daran, dass Ersterer keine Threadsicherheit berücksichtigen muss.

Unterschiede zwischen den dreien

Der wesentliche Leistungsunterschied zwischen String-Typ und StringBuffer: String ist ein unveränderliches Objekt, daher wird bei jeder Änderung eines String-Typs ein neues String-Objekt erzeugt und anschließend der Zeiger auf das neue String-Objekt gerichtet. Daher sollte für Strings, deren Inhalt sich häufig ändert, nicht String verwendet werden, denn das Erzeugen eines Objekts bei jeder Änderung beeinträchtigt die Systemleistung; besonders wenn sich viele nicht referenzierte Objekte im Speicher befinden, beginnt der GC der JVM zu arbeiten, und die Leistung sinkt.

Bei Verwendung der StringBuffer-Klasse werden die Operationen jedes Mal am StringBuffer-Objekt selbst ausgeführt, statt neue Objekte zu erzeugen und Objektreferenzen zu ändern. Daher wird in den meisten Fällen StringBuffer empfohlen, besonders wenn sich String-Objekte häufig ändern.

In bestimmten Spezialfällen wird die String-Verkettung von String-Objekten tatsächlich vom Java-Compiler in eine Verkettung von StringBuffer-Objekten kompiliert, sodass String-Objekte in diesen Fällen nicht langsamer als StringBuffer-Objekte sind, zum Beispiel:

String s1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

Die Geschwindigkeit beim Erzeugen des String-Objekts s1 ist nicht langsamer als bei StringBuffer. Tatsächlich wird im Java-Compiler die folgende Konvertierung automatisch durchgeführt:

Der Java-Compiler kompiliert die erste obige Anweisung direkt zu:

String s1 = “This is only a simple test”;  

Die Geschwindigkeit ist also sehr hoch. Es ist jedoch zu beachten, dass der Java-Compiler sie nicht automatisch umwandelt, wenn die verketteten Zeichenketten von anderen String-Objekten stammen, und die Geschwindigkeit dann nicht so hoch ist, zum Beispiel:

String s2 = “This is only a”;  
String s3 = “ simple”;  
String s4 = “ test”;  
String s1 = s2 + s3 + s4;  

Zu diesem Zeitpunkt verfährt der Java-Compiler strikt auf die ursprüngliche Weise. Die Verkettungsoperation von String (d. h. +) wird mit der append-Methode von StringBuilder (oder StringBuffer) implementiert. In diesem Fall muss für die obige Situation, wenn s2, s3 und s4 als String definiert sind, während der Verkettung ein zusätzlicher StringBuffer (oder StringBuilder) erstellt und dann der StringBuffer in String umgewandelt werden. Wenn StringBuffer (oder StringBuilder) verwendet wird, muss kein zusätzlicher StringBuffer erstellt werden.

Verwendungsstrategien

• (1) Grundprinzip: Wenn Sie mit einer kleinen Datenmenge arbeiten möchten, verwenden Sie String; für den Single-Thread-Betrieb mit großen Datenmengen verwenden Sie StringBuilder; für den Multi-Thread-Betrieb mit großen Datenmengen verwenden Sie StringBuffer.

• (2) Verwenden Sie nicht das "+" der String-Klasse für häufige Verkettungen, da die Leistung extrem schlecht ist. Sie sollten die Klasse StringBuffer oder StringBuilder verwenden. Dies ist ein relativ wichtiges Prinzip in der Java-Optimierung. Zum Beispiel:

  String result = "";
  for (String s : hugeArray) {
      result = result + s;
  }
  
  // 使用StringBuilder
  StringBuilder sb = new StringBuilder();
  for (String s : hugeArray) {
      sb.append(s);
  }
  String result = sb.toString();
  

  Wenn die obige Situation auftritt, sollten wir offensichtlich die zweite Methode verwenden, denn bei der ersten Methode wird jede Schleifeein String-Ergebnis erstellen, um das Ergebnis zu speichern. Abgesehen davon sind die beiden im Wesentlichen gleich (fürJDK 1.5 und spätere Versionen）。

• (3) Um eine bessere Leistung zu erzielen, sollten Sie beim Erstellen von StringBuffer oder StringBuilder deren Kapazität möglichst angeben. Wenn die Länge der Zeichenkette, mit der Sie arbeiten, 16 Zeichen nicht überschreitet, müssen Sie sie natürlich nicht angeben. Wenn keine Kapazität angegeben wird, wird standardmäßig ein Objekt mit einer Kapazität von 16 erstellt. Die Nichtangabe der Kapazität verringert die Leistung erheblich.

• (4) StringBuilder wird im Allgemeinen innerhalb von Methoden verwendet, um ähnliche+Funktionen auszuführen. Da er nicht thread-sicher ist, kann er nach der Verwendung verworfen werden. StringBuffer wird hauptsächlich für globale Variablen verwendet.

• (5) Unter denselben Bedingungen kann durch die Verwendung von StringBuilder im Vergleich zur Verwendung von StringBuffer nur eine Leistungsverbesserung von etwa 10%~15% erreicht werden, aber es birgt die Gefahr, nicht thread-sicher zu sein. In der echten modularen Programmierung kann der für ein bestimmtes Modul verantwortliche Programmierer möglicherweise nicht klar bestimmen, ob das Modul in einer Multithread-Umgebung ausgeführt wird. Daher: Es sei denn, Sie sind sicher, dass der Systemengpass bei StringBuffer liegt und dass Ihr Modul nicht im Multithread-Modus ausgeführt wird, können Sie StringBuilder verwenden; andernfalls verwenden Sie weiterhin StringBuffer.

Artikelquelle: https://blog.csdn.net/kingzone_2008/article/details/9220691