funciones - string java example
¿Existe una "manera más rápida" de construir cadenas en Java? (9)
¿Estás 100% seguro de que el instructor no estaba hablando de algo como:
String foo = "" + 123456;
Veo que mis alumnos hacen ese tipo de cosas "todo el tiempo" (un puñado lo hará en cada término). La razón por la que lo hacen es que algún libro les mostró cómo hacerlo de esa manera. ¡Sacude la cabeza y el puño a los perezosos escritores de libros!
Normalmente creo una cadena en Java de la siguiente manera:
String foo = "123456";
Sin embargo, mi profesor me ha insistido en que forme una cadena usando el método de format , así:
String foo = String.format("%s", 123456);
Es mucho mas rapido
Además, dice que usar la clase StringBuilder es incluso más rápido.
StringBuilder sb = new StringBuilder(); String foo = sb.append(String.format("%s", 123456)).toString();
¿Cuál es el método más rápido para crear una cadena, si es que existe ?
No podrían ser 100% exactos ya que podría no recordarlos completamente.
Como se ha señalado, si solo está creando una única cadena sin concatenación, simplemente use la Cadena.
Para concatenar múltiples bits en una cadena grande, StringBuffer es más lento que StringBuilder, pero StringBuffer está sincronizado. Si no necesitas sincronización, StringBuilder.
El primer ejemplo que dio es el más rápido y el más simple. Usa eso.
Cada pieza de código que agregó en esos ejemplos hace que sea significativamente más lento y más difícil de leer.
Sugeriría que el ejemplo 2 es al menos 10-100x más lento que el ejemplo 1 y el ejemplo 3 es aproximadamente 2x más lento que el ejemplo 2.
¿Su procesador proporcionó alguna justificación para esta afirmación?
Por cierto: tu primer ejemplo no construye una cadena en absoluto (por lo que es la más rápida), solo te da una cadena que se sienta en el grupo de constantes de cadenas.
En tu segundo ejemplo, usando:
String foo = String.format("%s", 123456);
no te compra nada; 123456 ya es un valor constante, entonces ¿por qué no simplemente asigna foo = "123456"? Para las cadenas constantes, no hay mejor manera.
Si está creando una cadena de varias partes que se agregan juntas en el tiempo de ejecución, use StringBuffer o StringBuilder (la primera es segura para subprocesos).
Si solo hay una cadena, entonces:
String foo = "123456";
Es el mas rapido Notarás que la línea String.format tiene "%s%" declarado, así que no veo cómo el profesor podría pensar que fue más rápido. Además, tienes una llamada al método encima.
Sin embargo, si creas una cadena a lo largo del tiempo, como en un bucle for, querrás usar un StringBuilder. Si solo utilizara += entonces está creando una nueva cadena cada vez que se llama a la línea += . StringBuilder es mucho más rápido, ya que contiene un búfer y se agrega a eso cada vez que se llama a append .
Si su cadena es conocida en tiempo de compilación, entonces es mejor usar un literal: String foo = "123456"; .
Si su cadena no se conoce en tiempo de compilación y se compone de una agregación de cadenas más pequeñas, StringBuilder suele ser el camino a seguir (¡pero tenga cuidado con la seguridad de las hebras!).
Usando String foo = String.format("%s", 123456); podría reducir el tamaño de su clase y hacer que la carga de la clase sea un poco más rápida, pero eso sería un ajuste de memoria extremadamente agresivo (extremo) ^^.
Toda esta discusión es discutible. Por favor, lea este artículo de Jeff, es decir, el tipo que creó .
La triste tragedia del teatro de micro-optimización
Remita a su instructor a esta publicación y pídale que deje de arruinar el cerebro de su estudiante con información inútil. Las optimizaciones algorítmicas son donde tu código vivirá o morirá, no con el método que utilices para construir cadenas. En cualquier caso, StringBuilder y el formateador de cadenas tienen que ejecutar ACTUAL CODE con REAL MEMORY, si solo construyes una cadena que se deja de lado durante el tiempo de compilación y está listo para ser usado cuando lo necesites, en esencia, tiene 0 run costo de tiempo, mientras que las otras opciones tienen un costo real, ya que el código realmente necesita ejecutarse.
Un poco fuera de tema, pero deseo que desaparezca todo el mito de que "no se debe usar más para concatenar cadenas en Java". Si bien podría haber sido cierto en las primeras versiones de Java que StringBuffer era más rápido y "+ era malvado", ciertamente no es cierto en las JVM modernas que están cuidando muchas optimizaciones.
Por ejemplo, ¿cuál es más rápido?
String s = "abc" + "def";
o
StringBuffer buf = new StringBuffer();
buf.append("abc");
buf.append("def");
String s = buf.toString();
La respuesta es la primera. La JVM reconoce que se trata de una constante de cadena y en realidad colocará "abcdef" en el conjunto de cadenas, mientras que la versión "optimizado stringbuffer" hará que se construya un objeto StringBuffer adicional.
Otra optimización de JVM es
String s = onestring + " concat " + anotherstring;
Donde la JVM resolverá cuál será la mejor forma de concatenar. En JDK 5, esto significa que un StringBuilder se usará internamente y será más rápido que usar un buffer de cadena.
Pero como han dicho otras respuestas, la constante "123456" en su pregunta es ciertamente la forma más rápida y su profesor debería volver a ser un estudiante :-)
Y sí, he estado lo suficientemente triste como para verificar esto mirando el código de bytes de Java ...
String foo = "some string literal";
Es sin duda la forma más rápida de hacer una cadena. Está incrustado en el archivo .class y es una búsqueda de memoria simple para recuperar.
El uso de String.format cuando no tienes nada que formatear realmente solo parece feo y puede hacer que los desarrolladores junior lloren.
Si la cadena se va a modificar, entonces StringBuilder es el mejor ya que las Strings son immutable .