String vs StringBuilder vs StringBuffer en Java

Una string es una secuencia de caracteres. En java, los objetos de String son inmutables, lo que significa una constante y no se pueden cambiar una vez creados. Inicializar una string  es uno de los pilares importantes requeridos como requisito previo con una comprensión más profunda. Por ahora, justificaremos, consideremos el siguiente código con tres funciones de concatenación con tres tipos diferentes de parámetros, String, StringBuffer y StringBuilder. Aclaremos el entendimiento entre ellos a través de un solo programa java a continuación del cual sacaremos conclusiones de la salida generada para descubrir las diferencias entre String vs StringBuilder vs StringBuffer en Java.

Ejemplo

// Java program to demonstrate difference between
// String, StringBuilder and StringBuffer
 
// Main class
class GFG {
 
    // Method 1
    // Concatenates to String
    public static void concat1(String s1)
    {
        s1 = s1 + "forgeeks";
    }
 
    // Method 2
    // Concatenates to StringBuilder
    public static void concat2(StringBuilder s2)
    {
        s2.append("forgeeks");
    }
 
    // Method 3
    // Concatenates to StringBuffer
    public static void concat3(StringBuffer s3)
    {
        s3.append("forgeeks");
    }
 
    // Method 4
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input string
        // String 1
        String s1 = "Geeks";
 
        // Calling above defined method
        concat1(s1);
 
        // s1 is not changed
        System.out.println("String: " + s1);
 
        // String 1
        StringBuilder s2 = new StringBuilder("Geeks");
 
        // Calling above defined method
        concat2(s2);
 
        // s2 is changed
        System.out.println("StringBuilder: " + s2);
 
        // String 3
        StringBuffer s3 = new StringBuffer("Geeks");
 
        // Calling above defined method
        concat3(s3);
 
        // s3 is changed
        System.out.println("StringBuffer: " + s3);
    }
}

String: Geeks
StringBuilder: Geeksforgeeks
StringBuffer: Geeksforgeeks

 Explicación de salida: 

• Concat1 : en este método, pasamos una string «Geeks» y ejecutamos «s1 = s1 + ”forgeeks». La string pasada desde main() no cambia, esto se debe al hecho de que String es inmutable . Alterar el valor de la string crea otro objeto y s1 en concat1() almacena la referencia de la nueva string. Las referencias s1 en main() y cocat1() se refieren a diferentes strings.
• Concat2 : en este método, pasamos una string «Geeks» y ejecutamos «s2.append («forgeeks»)» que cambia el valor real de la string (en principal) a «Geeksforgeeks». Esto se debe al simple hecho de que StringBuilder es mutable y, por lo tanto, cambia su valor.
• Concat3 : StringBuilder es similar y puede ser compatible en todos los lugares con StringBuffer, excepto por la diferencia clave de la seguridad de subprocesos. StringBuffer es seguro para subprocesos, mientras que StringBuilder no garantiza la seguridad de subprocesos, lo que significa que los métodos sincronizados están presentes en StringBuffer para controlar el acceso de un subproceso a la vez mientras no se ve en StringBuilder, por lo tanto, no es seguro para subprocesos.
   

Nota: Geeks ahora debe preguntarse cuándo usar cuál, consulte a continuación de la siguiente manera:

• Si una string va a permanecer constante a lo largo del programa, use el objeto de clase String porque un objeto String es inmutable.
• Si una string puede cambiar (por ejemplo: mucha lógica y operaciones en la construcción de la string) y solo se accederá desde un solo hilo, usar un StringBuilder es lo suficientemente bueno.
• Si una string puede cambiar y se accederá a ella desde varios subprocesos, use un StringBuffer porque StringBuffer es síncrono, por lo que tiene seguridad para subprocesos.
• Si no desea seguridad para subprocesos, también puede optar por la clase StringBuilder, ya que no está sincronizada.

Conversión entre tipos de strings en Java

A veces es necesario convertir un objeto de string de diferentes clases como String, StringBuffer, StringBuilder entre sí. A continuación se presentan algunas técnicas para hacer lo mismo. Cubrimos todos los casos de uso siguientes:

1. De String a StringBuffer y StringBuilder
2. De StringBuffer y StringBuilder a String
3. De StringBuffer a StringBuilder o viceversa

Caso 1: De String a StringBuffer y StringBuilder 

Esta es una salida fácil, ya que podemos pasar directamente el objeto de la clase String a los constructores de las clases StringBuffer y StringBuilder. Como la clase String es inmutable en Java, para editar una string, podemos hacer lo mismo convirtiéndola en objetos de clase StringBuffer o StringBuilder.

Ejemplo  

// Java program to demonstrate conversion from
// String to StringBuffer and StringBuilder
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input string
        String str = "Geeks";
 
        // Converting String object to StringBuffer object
        // by
        // creating object of StringBuffer class
        StringBuffer sbr = new StringBuffer(str);
 
        // Reversing the string
        sbr.reverse();
 
        // Printing the reversed string
        System.out.println(sbr);
 
        // Converting String object to StringBuilder object
        StringBuilder sbl = new StringBuilder(str);
 
        // Adding it to string using append() method
        sbl.append("ForGeeks");
 
        // Print and display the above appended string
        System.out.println(sbl);
    }
}

skeeG
GeeksForGeeks

 Caso 2: De StringBuffer y StringBuilder a String 

Esta conversión se puede realizar usando el método toString() que se anula en las clases StringBuffer y StringBuilder. A continuación se muestra el programa Java para demostrar lo mismo. Tenga en cuenta que mientras usamos el método toString() , se asigna e inicializa un nuevo objeto String (en el área Heap) a la secuencia de caracteres actualmente representada por el objeto StringBuffer, lo que significa que los cambios posteriores al objeto StringBuffer no afectan el contenido del Objeto de string. 

Ejemplo

// Java Program to Demonstrate Conversion from
// String to StringBuffer and StringBuilder
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating objects of StringBuffer class
        StringBuffer sbr = new StringBuffer("Geeks");
        StringBuilder sbdr = new StringBuilder("Hello");
 
        // Converting StringBuffer object to String
        // using toString() method
        String str = sbr.toString();
 
        // Printing the above string
        System.out.println(
            "StringBuffer object to String : ");
        System.out.println(str);
 
        // Converting StringBuilder object to String
        String str1 = sbdr.toString();
 
        // Printing the above string
        System.out.println(
            "StringBuilder object to String : ");
        System.out.println(str1);
 
        // Changing StringBuffer object sbr
        // but String object(str) doesn't change
        sbr.append("ForGeeks");
 
        // Printing the above two strings on console
        System.out.println(sbr);
        System.out.println(str);
    }
}

StringBuffer object to String : 
Geeks
StringBuilder object to String : 
Hello
GeeksForGeeks
Geeks

Caso 3: De StringBuffer a StringBuilder o viceversa

Esta conversión es complicada. No hay una forma directa de convertir lo mismo. En este caso, podemos usar un objeto de clase String. Primero convertimos el objeto StringBuffer/StringBuilder a String usando el método toString() y luego de String a StringBuilder/StringBuffer usando constructores.

Ejemplo

// Java program to Demonstrate conversion from
// String to StringBuffer and StringBuilder
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating object of StringBuffer class and
        // passing our input string to it
        StringBuffer sbr = new StringBuffer("Geeks");
 
        // Storing value StringBuffer object in String and
        // henceforth converting StringBuffer object to
        // StringBuilder class
        String str = sbr.toString();
        StringBuilder sbl = new StringBuilder(str);
 
        // Printing the StringBuilder object on console
        System.out.println(sbl);
    }
}

Geeks

De los tres casos de uso anteriores, podemos concluir los siguientes consejos: 

• Los objetos de String son inmutables y los objetos de StringBuffer y StringBuilder son mutables.
• StringBuffer y StringBuilder son similares, pero StringBuilder es más rápido y se prefiere a StringBuffer para el programa de subproceso único. Si se necesita seguridad de subprocesos, se utiliza StringBuffer.

Artículo relacionado:  Invierta una string en Java (5 maneras diferentes) Pranjal y Gaurav Miglani
contribuyeron con este artículo . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.