Diferența dintre String, StringBuffer și StringBuilder în Java - Exemplu atașat

Publicat: 2022-01-30
Diferența dintre String, StringBuffer și StringBuilder în Java - Comparație și exemplu atașat

În acest tutorial Java vom analiza diferența dintre Java String, StringBuffer și StringBuilder.

Să începem:

Şir:

Clasa String reprezintă șiruri de caractere. Toate literalele șir din programele Java, cum ar fi „crunchify”, sunt implementate ca instanțe ale acestei clase. Șirurile sunt constante; valorile lor nu pot fi modificate după ce sunt create.

StringBuffer:

O secvență de caractere care poate fi folosită și poate fi mutată. Un buffer de șir este ca un șir, dar poate fi modificat.

În orice moment, conține o anumită secvență de caractere, dar lungimea și conținutul secvenței pot fi modificate prin anumite apeluri de metodă.

Bufferele de șiruri sunt sigure pentru utilizare de mai multe fire.

StringBuilder:

O secvență mutabilă de caractere. Această clasă oferă un API compatibil cu StringBuffer, dar fără garanție de sincronizare.

Această clasă este concepută pentru a fi utilizată ca înlocuitor pentru StringBuffer în locurile în care buffer-ul șir a fost folosit de un singur fir (cum este în general cazul).

Acolo unde este posibil, se recomandă ca această clasă să fie folosită de preferință StringBuffer, deoarece va fi mai rapidă în majoritatea implementărilor.

Să comparăm toate caracteristicile de mai jos ale String, StringBuffer și StringBuilder.

Şir StringBuffer StringBuilder
Fir de siguranta? da da Nu
Sincronizat? da da Nu
Modificabil? Nu (imuabil) Da (mutabil) Da (mutabil)
Depozitare String Pool Morman Morman
Performanţă Încet Rapid Mai repede

Cod Java:

  • Creați clasa: CrunchifyStringVsStringBufferVsStringBuilder.java
  • Pune codul de mai jos în el
  • Salvează fișierul

În acest tutorial, adăugăm și adăugăm șiruri de 199999 de ori.

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 ) ;
     }
}
 

Consola IntelliJ IDEA Rezultat:

Rulați programul de mai sus ca aplicație Java în IntelliJ IDEA sau în Consola Eclipse și veți avea ca rezultat ca mai jos.

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
 

Anunțați-mă dacă vă confruntați cu vreo problemă la rularea programului de mai sus sau aveți întrebări între String, StringBuffer și StringBuilder.