Unterschied zwischen String, StringBuffer und StringBuilder in Java – Beispiel anbei

Veröffentlicht: 2022-01-30
Unterschied zwischen String, StringBuffer und StringBuilder in Java - Vergleich und Beispiel anbei

In diesem Java-Tutorial gehen wir auf den Unterschied zwischen Java String, StringBuffer und StringBuilder ein.

Lass uns anfangen:

Zeichenfolge:

Die String-Klasse repräsentiert Zeichenfolgen. Alle String-Literale in Java-Programmen, wie zB „crunchify“, sind als Instanzen dieser Klasse implementiert. Zeichenfolgen sind konstant; Ihre Werte können nach ihrer Erstellung nicht mehr geändert werden.

Zeichenfolgenpuffer:

Eine Thread-sichere, änderbare Zeichenfolge. Ein Zeichenfolgenpuffer ist wie eine Zeichenfolge, kann jedoch geändert werden.

Es enthält zu jedem Zeitpunkt eine bestimmte Zeichenfolge, aber die Länge und der Inhalt der Zeichenfolge können durch bestimmte Methodenaufrufe geändert werden.

Zeichenfolgenpuffer können sicher von mehreren Threads verwendet werden.

StringBuilder:

Eine veränderliche Folge von Zeichen. Diese Klasse stellt eine API bereit, die mit StringBuffer kompatibel ist, jedoch keine Synchronisationsgarantie bietet.

Diese Klasse ist für die Verwendung als Drop-In-Ersatz für StringBuffer an Stellen konzipiert, an denen der Zeichenfolgenpuffer von einem einzelnen Thread verwendet wurde (wie dies im Allgemeinen der Fall ist).

Wenn möglich, wird empfohlen, diese Klasse StringBuffer vorzuziehen, da sie unter den meisten Implementierungen schneller ist.

Lassen Sie uns alle untenstehenden Merkmale von String, StringBuffer und StringBuilder vergleichen.

Schnur Zeichenfolgenpuffer StringBuilder
Threadsicher? Jawohl Jawohl Nein
Synchronisiert? Jawohl Jawohl Nein
Modifizierbar? Nein (unveränderlich) Ja (änderbar) Ja (änderbar)
Lager String-Pool Haufen Haufen
Leistung Schleppend Schnell Schneller

Java-Code:

  • Klasse erstellen: CrunchifyStringVsStringBufferVsStringBuilder.java
  • Fügen Sie den folgenden Code ein
  • Datei speichern

In diesem Tutorial fügen wir Strings insgesamt 199999 Mal hinzu und hängen sie an.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package crunchify . com . tutorial ;
 
/**
* @author Crunchify.com
* Program: Difference between String, StringBuffer and StringBuilder in Java - Example attached
*/
 
public class CrunchifyStringVsStringBufferVsStringBuilder {
 
     public static void main ( String [ ] args ) {
 
         // String: The String class represents character strings. All string literals
         // in Java programs, such as "abc", are implemented as instances of this class.
         // Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings.
         // Because String objects are immutable they can be shared.
         String crunchifyString = "" ;
         long crunchifyBefore = System . currentTimeMillis ( ) ;
         for ( int i = 0 ; i < 199999 ; i ++ ) {
             crunchifyString = crunchifyString + "crunchify.com" ;
         }
 
         long crunchifyAfter = ( System . currentTimeMillis ( ) ) ;
         crunchifyPrint ( "Task Completion Time for String: " + ( crunchifyAfter - crunchifyBefore ) ) ;
 
         // StringBuffer: A thread-safe, mutable sequence of characters. A string buffer is like a String,
         // but can be modified. At any point in time it contains some particular sequence of characters, but the length
         // and content of the sequence can be changed through certain method calls.
         //
         // String buffers are safe for use by multiple threads. The methods are synchronized where necessary so that all
         // the operations on any particular instance behave as if they occur in some serial order that is consistent with the order
         // of the method calls made by each of the individual threads involved.
         //
         // The principal operations on a StringBuffer are the append and insert methods,
         // which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends
         // or inserts the characters of that string to the string buffer.
         // The append method always adds these characters at the end of the buffer;
         // the insert method adds the characters at a specified point.
 
         crunchifyBefore = System . currentTimeMillis ( ) ;
         StringBuffer crunchifyStringBuffer = new StringBuffer ( ) ;
         for ( int i = 0 ; i < 199999 ; i ++ ) {
             crunchifyStringBuffer . append ( "crunchify.com" ) ;
         }
 
         crunchifyAfter = ( System . currentTimeMillis ( ) ) ;
         crunchifyPrint ( "Task Completion Time for StringBuffer: " + ( crunchifyAfter - crunchifyBefore ) ) ;
 
         // StringBuilder: A mutable sequence of characters.
         // This class provides an API compatible with StringBuffer, but with no guarantee of synchronization.
         // This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread
         // (as is generally the case). Where possible,
         // it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.
         //
         // The principal operations on a StringBuilder are the append and insert methods,
         // which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends
         // or inserts the characters of that string to the string builder.
         // The append method always adds these characters at the end of the builder; the insert method adds the characters at a specified point.
 
         crunchifyBefore = System . currentTimeMillis ( ) ;
         StringBuilder crunchifyStringBuilder ;
         crunchifyStringBuilder = new StringBuilder ( ) ;
 
         for ( int i = 0 ; i < 199999 ; i ++ ) {
             crunchifyStringBuilder . append ( "crunchify.com" ) ;
         }
         // OR using repeat().
         // crunchifyStringBuilder.append("crunchify.com".repeat(199999));
         // repeat(): Returns a string whose value is the concatenation of this string repeated count times.
 
         crunchifyAfter = ( System . currentTimeMillis ( ) ) ;
         crunchifyPrint ( "Task Completion Time for StringBuilder: " + ( crunchifyAfter - crunchifyBefore ) ) ;
 
     }
 
     private static void crunchifyPrint ( String s ) {
         System . out . println ( s ) ;
     }
}
 

Ergebnis der IntelliJ IDEA-Konsole:

Führen Sie das obige Programm als Java-Anwendung in IntelliJ IDEA oder in der Eclipse-Konsole aus, und Sie erhalten das folgende Ergebnis.

1
2
3
4
5
6
7
8
/ Users / app / app / Installation / jdk - 17.0.2.jdk / Contents / Home / bin / java - javaagent : / Applications / IntelliJ IDEA . app / Contents / lib / idea_rt . jar = 50109 : / Applications / IntelliJ IDEA . app / Contents / bin - Dfile . encoding = UTF - 8 - classpath : / Users / app / . m2 / repository / org / slf4j / log4j - over - slf4j / 1.7.32 / log4j - over - slf4j - 1.7.32.jar crunchify . com . tutorial . CrunchifyStringVsStringBuffer
 
Task Completion Time for String : 19648
Task Completion Time for StringBuffer : 7
Task Completion Time for StringBuilder : 3
 
Process finished with exit code 0
 

Lassen Sie mich wissen, wenn Sie auf ein Problem mit dem oben genannten Programm stoßen oder Fragen zwischen String, StringBuffer und StringBuilder haben.