string - manejo - Concatenación de cadenas con Groovy

manejo de cadenas en java

Question

¿Cuál es la mejor forma (idiomática) de concatenar cadenas en Groovy?

Opción 1:

calculateAccountNumber(bank, branch, checkDigit, account) {
    bank + branch + checkDigit + account
}

Opcion 2:

calculateAccountNumber(bank, branch, checkDigit, account) {
    "$bank$branch$checkDigit$account"
}

Fundé un punto interesante sobre este tema en el viejo sitio web de Groovy: Cosas que puedes hacer, pero mejor dejarlas sin hacer.

Al igual que en Java, puede concatenar cadenas con el símbolo "+". Pero Java solo necesita que uno de los dos elementos de una expresión "+" sea una Cadena, sin importar si está en el primer lugar o en el último. Java usará el método toString () en el objeto no String de su expresión "+". Pero en Groovy, solo debes estar seguro de que el primer elemento de tu expresión "+" implementa el método más () de la manera correcta, porque Groovy lo buscará y usará. En Groovy GDK, solo las clases Number y String / StringBuffer / Character tienen el método más () implementado para concatenar cadenas. Para evitar sorpresas, siempre use GStrings.

Answer 1

Siempre busco el segundo método (usando la plantilla de GString), aunque cuando hay más de un par de parámetros como los que tiene, tiendo a envolverlos en ${X} ya que me parece que lo hace más legible.

Ejecutar algunos puntos de referencia (utilizando el excelente módulo de GBench de Nagai Masato ) sobre estos métodos también muestra que la creación de plantillas es más rápida que los otros métodos:

@Grab( ''com.googlecode.gbench:gbench:0.3.0-groovy-2.0'' )
import gbench.*

def (foo,bar,baz) = [ ''foo'', ''bar'', ''baz'' ]
new BenchmarkBuilder().run( measureCpuTime:false ) {
  // Just add the strings
  ''String adder'' {
    foo + bar + baz
  }
  // Templating
  ''GString template'' {
    "$foo$bar$baz"
  }
  // I find this more readable
  ''Readable GString template'' {
    "${foo}${bar}${baz}"
  }
  // StringBuilder
  ''StringBuilder'' {
    new StringBuilder().append( foo )
                       .append( bar )
                       .append( baz )
                       .toString()
  }
  ''StringBuffer'' {
    new StringBuffer().append( foo )
                      .append( bar )
                      .append( baz )
                      .toString()
  }
}.prettyPrint()

Eso me da la siguiente salida en mi máquina:

Environment
===========
* Groovy: 2.0.0
* JVM: Java HotSpot(TM) 64-Bit Server VM (20.6-b01-415, Apple Inc.)
    * JRE: 1.6.0_31
    * Total Memory: 81.0625 MB
    * Maximum Memory: 123.9375 MB
* OS: Mac OS X (10.6.8, x86_64) 

Options
=======
* Warm Up: Auto 
* CPU Time Measurement: Off

String adder               539
GString template           245
Readable GString template  244
StringBuilder              318
StringBuffer               370

Entonces, con la legibilidad y la velocidad a favor, recomendaría la creación de plantillas ;-)

NB: Si agrega toString() al final de los métodos de GString para que el tipo de salida sea igual que las otras medidas, y lo haga una prueba más justa, StringBuilder y StringBuffer superan los métodos de GString para la velocidad. Sin embargo, como GString se puede usar en lugar de String para la mayoría de las cosas (solo se debe tener precaución con las claves Map y las sentencias SQL), en general se puede dejar sin esta conversión final.

Agregar estas pruebas (como se ha preguntado en los comentarios)

  ''GString template toString'' {
    "$foo$bar$baz".toString()
  }
  ''Readable GString template toString'' {
    "${foo}${bar}${baz}".toString()
  }

Ahora obtenemos los resultados:

String adder                        514
GString template                    267
Readable GString template           269
GString template toString           478
Readable GString template toString  480
StringBuilder                       321
StringBuffer                        369

Como puede ver (como dije), es más lento que StringBuilder o StringBuffer, pero aún un poco más rápido que agregar Strings ...

Pero aún mucho más legible.

Editar después de comentar por ruralcoder a continuación

Actualizado a la última gbench, cadenas más grandes para la concatenación y una prueba con un StringBuilder inicializado a un buen tamaño:

@Grab( ''org.gperfutils:gbench:0.4.2-groovy-2.1'' )

def (foo,bar,baz) = [ ''foo'' * 50, ''bar'' * 50, ''baz'' * 50 ]
benchmark {
  // Just add the strings
  ''String adder'' {
    foo + bar + baz
  }
  // Templating
  ''GString template'' {
    "$foo$bar$baz"
  }
  // I find this more readable
  ''Readable GString template'' {
    "${foo}${bar}${baz}"
  }
  ''GString template toString'' {
    "$foo$bar$baz".toString()
  }
  ''Readable GString template toString'' {
    "${foo}${bar}${baz}".toString()
  }
  // StringBuilder
  ''StringBuilder'' {
    new StringBuilder().append( foo )
                       .append( bar )
                       .append( baz )
                       .toString()
  }
  ''StringBuffer'' {
    new StringBuffer().append( foo )
                      .append( bar )
                      .append( baz )
                      .toString()
  }
  ''StringBuffer with Allocation'' {
    new StringBuffer( 512 ).append( foo )
                      .append( bar )
                      .append( baz )
                      .toString()
  }
}.prettyPrint()

da

Environment
===========
* Groovy: 2.1.6
* JVM: Java HotSpot(TM) 64-Bit Server VM (23.21-b01, Oracle Corporation)
    * JRE: 1.7.0_21
    * Total Memory: 467.375 MB
    * Maximum Memory: 1077.375 MB
* OS: Mac OS X (10.8.4, x86_64)

Options
=======
* Warm Up: Auto (- 60 sec)
* CPU Time Measurement: On

                                    user  system  cpu  real

String adder                         630       0  630   647
GString template                      29       0   29    31
Readable GString template             32       0   32    33
GString template toString            429       0  429   443
Readable GString template toString   428       1  429   441
StringBuilder                        383       1  384   396
StringBuffer                         395       1  396   409
StringBuffer with Allocation         277       0  277   286