Diferencia entre String, StringBuffer y StringBuilder en Java – Ejemplo adjunto

Publicado: 2022-01-30
Diferencia entre String, StringBuffer y StringBuilder en Java - Comparación y ejemplo adjunto

En este tutorial de Java, repasaremos la diferencia entre Java String, StringBuffer y StringBuilder.

Empecemos:

Cuerda:

La clase String representa cadenas de caracteres. Todos los literales de cadena en los programas de Java, como "crunchify", se implementan como instancias de esta clase. Las cadenas son constantes; sus valores no se pueden cambiar después de crearlos.

Buffer de cadena:

Una secuencia de caracteres mutable y segura para subprocesos. Un búfer de cadena es como una cadena, pero se puede modificar.

En cualquier momento, contiene una secuencia particular de caracteres, pero la longitud y el contenido de la secuencia se pueden cambiar a través de ciertas llamadas a métodos.

Los búferes de cadena son seguros para que los usen varios subprocesos.

Constructor de cadenas:

Una secuencia mutable de caracteres. Esta clase proporciona una API compatible con StringBuffer, pero sin garantía de sincronización.

Esta clase está diseñada para usarse como un reemplazo directo para StringBuffer en lugares donde el búfer de cadena estaba siendo utilizado por un solo subproceso (como suele ser el caso).

Siempre que sea posible, se recomienda utilizar esta clase con preferencia a StringBuffer, ya que será más rápida en la mayoría de las implementaciones.

Comparemos todas las características a continuación de String, StringBuffer y StringBuilder.

Cuerda StringBuffer Constructor de cadenas
¿A salvo de amenazas? sí sí No
¿Sincronizado? sí sí No
¿Modificable? No (inmutable) Sí (mutable) Sí (mutable)
Almacenamiento Grupo de cuerdas Montón Montón
Rendimiento Lento Rápido Más rápido

Código Java:

  • Crear clase: CrunchifyStringVsStringBufferVsStringBuilder.java
  • Ponga el siguiente código en él
  • Guardar el archivo

En este tutorial, estamos agregando sumando, agregando un total de cadenas 199999 veces.

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

Resultado de la consola IntelliJ IDEA:

Ejecute el programa anterior como una aplicación Java en IntelliJ IDEA o en Eclipse Console y obtendrá el siguiente resultado.

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
 

Avíseme si tiene algún problema al ejecutar el programa anterior o si tiene alguna pregunta entre String, StringBuffer y StringBuilder.