Diese Erklärung zu sehen ist gut, also werde ich sie umdrehen
Es gibt 3 Klassen in Java, die für Charakteroperationen verantwortlich sind.
1. Charakter ist eine einzelne Zeichenoperation.
2.String arbeitet auf einer Zeichenfolge, unveränderliche Klasse.
3.StringBuffer ist auch eine Operation auf einer Zeichenfolge und eine veränderliche Klasse.
String:
Es ist ein Objekt, kein primitiver Typ.
Es ist ein unveränderliches Objekt und sobald es erstellt wird, kann sein Wert nicht geändert werden.
Die Änderung vorhandener String -Objekte besteht darin, ein neues Objekt neu zu erstellen und den neuen Wert darin zu speichern.
String ist eine endgültige Klasse, dh sie kann nicht vererbt werden.
StringBuffer:
Es ist ein veränderliches Objekt.
Es kann nur von Konstruktoren erstellt werden,
StringBuffer sb = new StringBuffer ();
Hinweis: Es kann nicht durch Zuordnungssymbole bezahlt werden.
sb = "Willkommen hier!"; // Fehler
Nachdem das Objekt erstellt wurde, wird der Speicherplatz im Speicher zugewiesen und ein Null wird zunächst gespeichert.
SB.Append ("Hallo");
Die Effizienz von StringBuffer ist höher als die von String in String -Verkettung:
String str = new String ("Willkommen zu");
str += "hier";
Der Verarbeitungsschritt erstellt tatsächlich ein StringBuffer, dann append () und schließlich aufgerufen
Fügen Sie dann StringBuffer tosting () hinzu;
Auf diese Weise wird der String -Verbindungsbetrieb zusätzliche Vorgänge als StringBuffer haben, und natürlich wird die Effizienz reduziert.
Und da es sich bei dem String -Objekt um ein unveränderliches Objekt handelt, erstellt jede Operation von Sting ein neues Objekt, um den neuen Wert zu speichern.
Auf diese Weise ist das ursprüngliche Objekt nutzlos und wird auch Müll gesammelt.
Schauen Sie sich den folgenden Code an:
Wiederholen Sie 26 englische Briefe 5.000 Mal.
Die Codekopie lautet wie folgt:
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int Times = 5000;
long lstart1 = system.currentTimemillis ();
String str = "";
für (int i = 0; i <times; i ++) {
str += tempstr;
}
Long lend1 = System.currentTimemillis ();
lange Zeit = (lend1 - lstart1);
System.out.println (Zeit);
Leider ist mein Computer kein Supercomputer, und die Ergebnisse, die ich bekomme, sind nicht unbedingt jedes Mal gleich, normalerweise um 46687.
Das sind 46 Sekunden.
Schauen wir uns den folgenden Code an
Die Codekopie lautet wie folgt:
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int Times = 5000;
long lstart2 = system.currentTimemillis ();
StringBuffer sb = new StringBuffer ();
für (int i = 0; i <times; i ++) {
sb.Append (tempstr);
}
Long lend2 = System.currentTimemillis ();
Langzeit2 = (lend2 - lstart2);
System.out.println (Time2);
Das Ergebnis ist 16 und manchmal ist es 0
Die Schlussfolgerung ist also offensichtlich, dass die Geschwindigkeit von StringBuffer fast Zehntausende von Malen der String beträgt. Natürlich sind diese Daten nicht sehr genau. Da die Anzahl der Zyklen 100.000 Mal beträgt, ist der Unterschied noch größer. Wenn Sie mir nicht glauben, versuchen Sie es mit
Wenn Sie immer noch nicht verstehen können:
1) Die Differenz zwischen der String -Methode der Joint + -Methode und der Anhangsmethode von StringBuff:
Wenn der String + -Operator den String -Betrieb ausführt, konvertiert er zunächst das aktuelle String -Objekt in StringBuff -Typ, suft seine Anhangmethode und konvertiert schließlich das generierte StringBuff -Objekt in eine String -Typ -Zeichenfolge über seine TOSTRING -Methode, sodass er ineffizient ist.
In Bezug auf die Lesbarkeit ist der Verbindungsoperator der String jedoch immer noch hoch.
2) StringBuff ist Thread-Safe
String ist nicht sicher für Threads
3) String ist ein String -Objekt, das nicht geändert werden kann, während StringBuff geändert wird.
Die Codekopie lautet wie folgt:
public static boolean filecopy (String srcstr, String deststr) {
Datei srcFile = null;
Datei destfile = null;
Reader reader = null;
Schriftsteller Schriftsteller = null;
boolesche Flagge = Falsch;
versuchen {
srcFile = neue Datei (SRCSTR);
if (! srcFile.exists ()) {
System.out.println ("Quelldatei existiert nicht");
System.exit (0);
} anders {
Reader = neuer FileReader (srcFile);
}
destfile = new Datei (deststr);
writer = new FileWriter (destfile);
char [] buff = new char [1024];
Int len;
String str = "";
StringBuffer sbuff = new StringBuffer ();
while ((len = reader.read (buff))! = -1) {
// str += new String (Buff, 0, len);
sbuff.Append (neuer String (Buff, 0, len));
}
// writer.write (str. tochararray ());
writer.write (sbuff.tostring (). toarArray ());
Flag = wahr;
writer.flush ();
reader.close ();
writer.close ();
} catch (ioException e) {
System.out.println ("Dateikopieausnahme: =" + e.getMessage ());
}
Rückflagge;
}