Tutorial Java SE - 35 StringBuilder

[@franciscoripollramirez9902]

La verdadera diferencia es que StringBuilder es mutable, por lo que no es thread-safe. El operador + crea un nuevo registro en heap memory

[@miguelperezmendez8964]

Excelente explicación 👏 me ayudaste mucho

[@eduardocontreras7874]

Pero que buen tips el de StringBuilder. Excelente la prueba para demostrar las diferencias de tiempo con el signo de concatenación

[@davidbecerramontellano7598]

Excelente opción para temas de rendimiento con aplicaciones escalables como haces mención en el video. Lo tendré en consideración con procesos grandes. Saludos.

[@brandojeanpiercalderonpuen3850]

Deberías hacer más videos como este con datos curiosos o rebuscados, buen video.

[@EduardoLynchAraya]

Excelente información, gracias, lo pondré en practica para mis futuras aplicaciones.
Saludos!

[@FranciscoRodriguez-vz6qd]

Buen dato, lo aplicaré en el futuro, gracias.

[@hansfelipe8968]

Lo consideraré, muchas gracias!

[@tomasheredia2901]

gracias, me ayudaste mucho.

[@bonillaleal]

Gracias por el video @MitoCode. Quisiera compartir el código con el método Scanner:
import java.util.Scanner;
public class Prueba{
public static void main(String args[ ]){
Scanner in=new Scanner(System.in);
StringBuilder palabra = new StringBuilder( );
System.out.println("Ingresar el texto a imprimir");
String texto=in.nextLine( );
palabra.append(texto);
System.out.println("El StringBuilder es: "+palabra.toString( ));
}
}

[@LeTocineJr]

Lo acabo de hacer asi;
import java.util.Scanner;
public class SBuilder {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
StringBuilder name = new StringBuilder();
System.out.println("Ingresa tu nombre");
name.append( sc.nextLine());
System.out.println("name = " + name);
}
}

[@zamoray123]

NO lo sabia, gracias Jaime

[@ZETA2008000]

¡Excelente...!
Pregunta: ¿A que se debe la utilización de la variable diferencia como un tipo double? si las variables tiempo_inicio y tiempo_fin son de tipo long.

[@rickhunter8216]

PARA QUE MUESTRE LAS MILESIMAS DE SEGUNDOS LUEGO DEL PUNTO DECIMAL.

[@PabloRodriguezMontero]

Muy buena observación. Creo que fue más como por el ejemplo que puso, pero efectivamente "System.nanoTime()" devuelve un long. Entonces, no debería haber ninguna diferencia sustancial (teniendo en cuenta que Java nos ayuda con la conversión implícita en el tipo de dato)

[@JuanCarlosLerma]

Buena información

[@MitoCode]

Genial 👏

[@maximilianomaubecin6493]

Este último tiempo mejoró bastante concatenar con el operador +, aunque StringBuilder llega a ser mejor. Sin embargo otra opción que es más óptima que esas dos es usar el método .concat(string) de la clase String. Por ej:
String texto = "";
texto.concat("Hola mundo");

[@PabloRodriguezMontero]

Hola, acabé de realizar la prueba con el método "concat(string)" y sigue siendo muy demorado. A continuación comparto el código:
public class Test {
public static void main(String[] args) {

final int TAMANIO = 100_000;
long inicio;
long fin;

System.out.println("Usando String con operador +");
inicio = System.currentTimeMillis();
String textoString = "";

for (int i = 0; i < TAMANIO; i++) {
textoString += i;
}
fin = System.currentTimeMillis();

System.out.println("->Se demoró: " + (fin-inicio));
System.out.println("-------------------------");

System.out.println("Usando String con método concat");
inicio = System.currentTimeMillis();
String textoStringConcat = "";

for (int i = 0; i < TAMANIO; i++) {
textoStringConcat = textoStringConcat.concat(String.valueOf(i));
}
fin = System.currentTimeMillis();

System.out.println("->Se demoró: " + (fin-inicio));
System.out.println("-------------------------");

System.out.println("Usando StringBuilder");
inicio = System.currentTimeMillis();
StringBuilder textoStringBuilder = new StringBuilder();

for (int i = 0; i < TAMANIO; i++) {
textoStringBuilder.append(i);
}
fin = System.currentTimeMillis();

System.out.println("->Se demoró: " + (fin-inicio));
System.out.println("-------------------------");

}
}
Y por ejemplo este fue el resultado de la salida en mi máquina:
Usando String con operador +
->Se demoró: 18752
-------------------------
Usando String con método concat
->Se demoró: 8038
-------------------------
Usando StringBuilder
->Se demoró: 4
-------------------------

[@cristophersaraosverdugo5934]

@@PabloRodriguezMontero increible la diferencia de rendimiento que tienen muchas gracias por aclararlo!

[@donhugorincon6785]

Hola muy buenos tus videos , Pedro podrías ser mas ordenado

[@CharipNet]

StringBuilder me da un error en eclipse version oxigen, cual podria ser el problema?..

[@rickhunter8216]

BUEN DATO LO DE JAVAMAIL.

[@ignacioantoniojeriagarrido6877]

Interesante

[@israel31294]

En la industria usamos el Stringbuilder de manera muy común

[@henryserranoa]

Es decir que el stringbuilder no es inmutable?

[@MitoCode]

+Henry Serrano aja stringbuilder y es StringBuffer son mutantes

[@MitoCode]

+Henry Serrano mutables jaja

[@rickhunter8216]

COMO LOS XMEN?

[@seichieduardojonda7290]

Lo mismo sucede con Stream y Lambdas, se demoran

[@jesussandrea7581]

pelos