Both String and StringBuilder can be used to handle strings. If the program uses only a few string objects, it probably doesn’t matter which class you use. (Actually, using Stringwould be better because the Stringobject initializes faster than StringBuilder). However, if you are creating many String objects, you need to think about it.

Use the Stringclass for strings that do not change; otherwise, use StringBuilder.

Specifically, if you are performing multiple string concatenation operations, definitely use StringBuilder rather than String. If you use String, a new object will be created each time string addition (+) is performed. On the other hand, StringBuliderwill use a single object for concatenation. The following code snippet illustrates the difference. Two label objects, label1and label2, are used to display the elapse times of using Stringand StringBuilder.

This code uses String and StringBuilderfor the same task: concatenating strings 5000 times. Both strings are initialized with the same string literal: “This is a test string”. We measure the elapsed time in both cases. Here is the result of one run on a Smartphone emulator:

❑ String elapse time: 4 milliseconds

❑ StringBuilder elapse time: 2 milliseconds

As you can see, using StringBuilder for a large number of string concatenations is much faster than using String. Using String.Concat() instead of the addition operator of String yields similar results. By turning on performance counters (see below), you can obtain more detailed information about managed string objects. The following example shows the result of using the selected performance counters introduced early in this chapter to compare String and StringBuilder performance.

Using only String for the concatenation:

Managed String Objects Allocated 5125

Bytes of String Objects Allocated 50232832

Garbage Collections (GC) 53

Using only StringBuilderfor the concatenation:

Managed String Objects Allocated 134

Bytes of String Objects Allocated 35580

Garbage Collections (GC) 0

In the first case, there are more than 5000 Stringobjects allocated, and the garbage collector has run 53 times. The overhead of creating and garbage-collecting those String objects is probably the leading cause of poor performance. When using StringBuilder, only 134 String objects are created, and because not too much heap space has been taken, the garbage collection does not even run.

Note that the preceding sample code uses Debug.Writeln() to display text strings in the console. The Debugclass is in the System.Diagnosticsnamespace. In fact, you can build a console project for Windows Mobile Smartphone devices and use Debug.Writeln()to output debug information to standard output. (If you debug the program in Visual Studio, standard output can be viewed in the output window.)

Recently, a colleague and I found ourselves in the situation of needing to concatenate values from multiple rows of a MS SqlServer database table. We were trying to form a comma-delimited list of phone numbers for every customer in our database. One customer may have many phone numbers. Here is a simplified diagram visualizing the relationship between customer and phone numbers:

Customer - Phone Number Relationship

The format of data we were looking for was:

We tried various queries to perform the concatenation correctly but none of our solutions seemed to do the job perfectly; either the final ‘PhoneNumbers’ string would have an additional comma at the end or some other undesired effect. We finally came across an article explaining in great detail of how to use TSQL (the SQL engine behind SqlServer) to perform the operations we needed.

http://www.projectdmx.com/tsql/rowconcatenate.aspx

This article has various examples describing AND explaining how to do multiple row value concatenations such as explicit examples for “Concatenating values when the number of items is small and known upfront” and “Concatenating values when the number of items is not known”. The author even walks through a recursive solution or two.

We determined that we knew none of our customers had more than five phone numbers based on the fact that they were limited to the PhoneType enumeration which only has five values. This allowed us to use the articles first example to get our job done efficiently. Here is our final solution:

SELECT CustomertId, REPLACE(
 '"' + MAX( CASE seq WHEN 1 THEN phoneNumber ELSE '' END ) + '",' +
 '"' + MAX( CASE seq WHEN 2 THEN phoneNumber ELSE '' END ) + '",' +
 '"' + MAX( CASE seq WHEN 3 THEN phoneNumber ELSE '' END ) + '",' +
 '"' + MAX( CASE seq WHEN 4 THEN phoneNumber ELSE '' END ) + '",' +
 '"' + MAX( CASE seq WHEN 5 THEN phoneNumber ELSE '' END ) + '"', ',""', '' ) as PhoneNumbers
FROM (
 SELECT pn1.CustomerId, pn1.PhoneNumber, (
 SELECT COUNT(*)
 FROM PhoneNumber pn2
 WHERE pn2.CustomerId = pn1.CustomerId
 AND pn2.phoneNumber <= pn1.phoneNumber)
 FROM PhoneNumber pn1) PhoneNumbersPerParty ( CustomerId, phoneNumber, seq )
GROUP BY CustomerId
By: Jesse Webb

maksutnya supaya lebih mudah diprogramnya, namun apa daya performansinya jauh mengecewakan. itulah yang terjadi saat saya akan menyimpan sebuah array of double dengan menggunakan c#. simple problem :

wow … dashyattt ….
string concate c# sucksss …..

Phonoloblog melder at ConCat (Constraint Catalogue) har vorte vaksen: ein wiki med optimalitetsteoretiske… ja, kva skal ein kalle det på norsk? Eg har brukt «føringar», men har vorte meir glad i «krav», somme bruker «betingelser», og på engelsk kallar dei det «constraints», som etter ordboka kan omsetjast med «restriksjonar». I alle fall, ConCat er her.

Joining columns and results together is really easy in Oracle or MySQL, in both there is the same function – CONCAT().

However you should be aware that there are differences between the databases on how this function works. In MySQL the CONCAT() function works by joining any number of items specified in the function – I don’t think that there is a limit? But with Oracle it seems that you can only join two strings at a time using this function.

Joining columns/ concatenate strings in Oracle PLSQL/ MySQL

¿Quién no ha usado cat en la consola de linux para algo alguna vez? Que tire la primera piedra!

Este me lo mostró un amigo hace algunos años y lo acabo de recordar por que he tenido que usarlo. Yo ni sabía que existía tal cosa…

El comando es tac, hace exactamente lo inverso a cat. Es decir, si mi archivo.txt contiene dos líneas: linea1 y linea2, hacer cat archivo.txt me devuelve:

~ $ cat archivo.txt
linea1
linea2

Si por otrto lado, uso tac, el resultado:

~ $ tac archivo.txt
linea2
linea1

Muy útil en esos casos en que necesitamos solo la cabecera de un archivo, por ejemplo.

i tried several methods but this was the best:

cat *.MPG | ffmpeg -i - -b 1500k -ar 44100 together.flv

the * goes in ordered state so if you have videos from your camera they are already ordered.

Hoje deixo uma dica simples, mas muito útil de como concatenar strings em C# usando o método estático Concat da classe String.
Veja como isso é feito no exemplo abaixo:

string frase1 = “Gosto de “;
string frase2 = “programar em C#”;
string frase3 = String.Concat(frase1, frase2);
Console.WriteLine(frase3);

Flex is a highly productive, free open source framework for building and maintaining expressive web applications that deploy consistently on all major browsers, desktops, and operating systems -Adobe

Adobe Flex is a collection of technologies released by Adobe Systems for the development and deployment of cross platform rich Internet applications based on the proprietary Adobe Flashplatform. The initial release in March 2004 by Macromedia included a software development kit, anIDE, and a J2EE integration application known as Flex Data Services. Since Adobe acquired Macromedia in 2005, subsequent releases of Flex no longer require a license for Flex Data Services, which has become a separate product rebranded as LiveCycle Data Services. -Wikipedia

There are many sites providing the tutorials and samples in net.Here is my Flex samples blog ,

http://gnanz-flexworld.blogspot.com

Here a few Prolog List-Operations I had to write at the University.

This is an annoying one. SharePoint will not allow you to create a site column from the UI (using the _layouts/fldnew.aspx page) if the name of the column is one of:

constructor, concat, join, pop, push, reverse, shift, slice, sort, splice or unshift

even if these site columns do not exist in the SharePoint site. If you try to create one of these fields you will get an error message saying that:

The column name that you entered is already in use or reserved. Choose another name.

Hmmm … Well after investigating this one it turned out to be a genuine bug caused by a JavaScript artifact. The way the fldnew.aspx page checks at the client side if a column already exists is by having all existing columns stored in a JavaScript Array called g_FieldName and then checking if the column that user tries to create is already in the array. This is done by the following code:

The problem with this code is that for some unknown to me reason which is probably related to the way the JavaScript VM is implemented, if you create a new Array called arr and then try to read arr["shift"] for example, this will return the following string:

And this happens on both Internet Explorer and Firefox. And this will happen for all strings that are names of methods of the JavaScript Array object and this is case sensitive. Because SharePoint does the check in lower case, then only the methods that are entirely in lower case will be a problem and the list of SharePoint site columns you won’t be able to create from the UI given at the top is the list of all methods of the Array object that are fully lower case.

So how to get around this. Well first of all this is a bug that should be resolved by Microsoft. They could either store everything in upper case (no JavaScript methods are fully upper case) or can change the function to

The problem with the first function is that g_FieldName[strName.toLowerCase()] will be evaluated to true for anything which is not 0, false, null or unknown. In the case of arr["shift"] it will return the string shown on the screen-shot above, which will be evaluated to “true”. So explicitly testing for “1″ will resolve the bug.

In the meantime if you need to create a site column with one of those names you could do it using code or features. And if you wonder how I discovered this issue – well I wanted to create a site column called “Shift” as in work shift which I consider as a totally legitimate use case.

Web Directory Script is a classifieds listings script, built in PHP. The site owner could configure this script in any way he wants. It will bring a lot of money to the site owner, without any spendings.

Web Directory Script may be used for auto, business, employment, personals, real estate and rentals listings.

This classifieds script was developed for a multi use. The site manager may configure it as a car seller site, employment directory or restaurants classifieds.

Gradasi

Lokasi AMIKOM, Concat, Depok, Sleman Yogyakarta, Indonesia

Kamera Kodak CX 7330
Lensa Kodak Built-In/Standard
Film Digital
Filter — Tidak Ada –
Kecepatan 1/1024
Diafragma f/6.7
Focal Length 9 mm

link : deviantart.com , ayofoto.net , fotografer.net

Chars  : Belirlenmiş bir karakterin yerine karakter ekler.
Length : Stringdeki karakter sayısını verir.
Compare : Belirlenmiş iki string nesnesini karakter sayılarına göre karşılaştırır.
Sonuç eşit ise “0”, büyükse “+1”, küçükse”-1” değerlerini döndürür.
CompareTo :  Belirlenen iki stringi alfabetik sıraya göre karşılaştır. Sonuç eşit ise “0”,
eşit değil ise “-1” değeri geri döndürür.
Concat : Stringi bir veya birden fazla string ile birleştirir. 
Contains  : String içerisinde belirlenmiş başka string nesnelerinin bulunup
bulun madığını kontrol eder.
Copy : Belirlenmiş bir string karakterlerini kullanarak yeni bir örnek string
oluşturur.
EndsWith :  Stringin sonunda belirli bir string örneğinin olup olmadığına karar verir.
Equals :  İki string nesnesinin aynı değerlere sahip olup olmadığı kontrol eder. True
veya false değerleri geri döndürür.
Format  : Stringi bilgiyi belli bir biçime dönüştürür.
GetEnumerator :  String içerisinde tekrar eden bir nesne bulur.
GetHashCode : Stringdeki bozuk kodu bulur.
GetType : Örneğin tipini verir.
GetTypeCode :  Stringin  Type code (Tür kodunu) çağırır.
IndexOf  : Stringin içindeki dizenin başlangıç noktasını bulur.
IndexOfAny  : Stringdeki herhangi bir karakterin başlangıç noktasını bulur.
Insert  : String içerisine karakter ekler.
IsNullOrEmpty : Stringin boş olup olmadığını gösterir.
LastIndexOf   : Bir karakter veya karakter grubunun stringin içinde bulunduğu pozisyonu
sayısal olarak ifade eder. (Eğer karakter veya karakter grubu string
içerisinde birden fazla ise en sondaki karakter veya karakter grubunun
sayısal olarak bulunduğu yeri belirtir.)
PadLeft : Stringin solundan başlayarak stringin boyutu verilen değere eşit olana
kadar istenilen karakter eklenir.
PadRight : Stringin sağından başlayarak stringin boyutu verilen değere eşit olana
kadar istenilen karakter eklenir.
ReferenceEquals Belirlenmiş nesne örneklerinin referans türle aynı olup olmadığına karar
verir.
Remove  : String içerisinde belirli sayıda karakter siler.
Replace :Stringin istediğimiz karakterlerini değiştirmek için kullanılır.
StartsWith : Belirlenen bir dizenin stringin başlangıcı olup olmadığını bulur. Boolean
tipte bir değer döndürür.
Substring  Stringde belirtilen bir karakterden başlayarak sabit sayıda karakter
döndürür.
ToCharArray :  Stringi dizi karakterlerine çevirir.
ToLower  :Stringdeki harfleri küçük harfe dönüştürür.
ToString : Bilgileri string türüne dönüştürür.
ToUpper  : Stringdeki harfleri büyük harfe dönüştürür.
Trim  : Stringin başında ve sonundaki boşlukları veya belirtilen karakterleri
kaldırır.
TrimEnd  : Stringin sonundaki boşlukları veya belirtilen karakterleri kaldırır.
TrimStart  : Stringin başındaki boşlukları veya belirtilen karakterleri kaldırır.

*—–KULLANIMI—-*

1.  a.Length = 1. stringin karakter uzunluğunu verir. Uzunluk bulunurken boşluklar
dâhil edilir.
2.  b.Chars(1) = 2  . stringin 1. elemanını ekrana yazdırır. Dikkat edilecek husus
stringin ilk karakteri  0. elemanıdır.
3.  a.CompareTo(b) = 1  . string ile 2. stringi karşılaştırır. İki string eşit -1 değeri
döndürür.
4.  String.Concat(a, b) = 1 . stringin sonuna 2. stringi ekler. 1. stringin sonunda
veya 2. stringin başında boşluk olmadığından stringler birleştirildiğinde arada
boşluk olmaz.
5.  a.Contains(”eslek”) = 1 .  string içerisinde “eslek” kelimesi olduğundan true
değeri döndürür.
6.  String.Copy(a) = 1. stringin kopyasını oluşturur.
7.  a.IndexOf(”düstri”) = “dustri”  stringinin 1. stringin kaçıncı karakterinden
itibaren başladığını gösterir. stringin ilk elemanı 0. karakterdir.
8.  b.Insert(3, “v”) = 2.  stringin 3. karakterine v harfini ekler.
9.  String.IsNullOrEmpty(b) = 2.  Stringin boş olup olmadığını kontrol eder. Boş
olmadığı için False değeri döndürür.
10.  a.LastIndexOf(”d”) = d harfinin 1. stringin kaçıncı karakteri olduğunu bulur.
11.  a.PadLeft(30, “?”) = 1 . stringin sol tarafına toplam uzunluk 30 karakter olana
kadar “?” işareti ekler.
12.  b.PadRight(15, “*”) = 2  .  stringin sağ tarafına toplam uzunluğu 15 karakter
olana kadar “*” işareti ekler.
13.  a.Remove(3, 5) = 1 . stringin 3. karakterinden başlayarak 5 karakter siler.
14.  b.ToUpper = 2 . stringin bütün karakterlerini büyük harfe çevirir.
15.  a.ToLower = 1 . stringin bütün karakterlerini küçük harfe çevirir.
16.  a.Trim(”En”) = 1 . stringin başında veya sonunda En kelimesi varsa bulup siler.
17.  a.Replace(”Meslek”, “Teknik”) = 1  . string içerisinde “Meslek” kelimesini
arayıp bulduğunda “Teknik” kelimesi ile yer değiştirir.

In PHP, the operator to concatenate or combine strings together is: . (dot)

Here are some examples of usage when concatenating strings:

<?php

$string1 = ‘tech’;
$string2 = ’saints’;
$string3 = ‘.com’;

$full = $string1.$string2.$string3;

echo $full;

?>

Result: techsaints.com

<?php

$string = ‘techsai’;
$string .= ‘nts’;
$string .= ‘.com’;

echo $str;

?>

Result: techsaints.com

<?php

$num = 123;

$string = $num.’ is a number’;

echo $string;

?>

Result: 123 is a number

When concatenating a number and a string, the string is automatically cast as a string.

I file immagine con rispettiva estensione .mdf e .mds sono file del SW per Windows, Alcohol 120%.
Per poter masterizzare questi file, dobbiamo per prima cosa convertirli in una .iso masticabile senza problemi da Toast 9.
Per far ciò ci servirà un fantastico tool freeware, Split and Concat.
Questo software è utilizzato anche per riunire i file spezzettati con Hjsplit.
Una volta uniti i due file, dovremo rinominare il file generato in “esempio.iso“.
Ora siamo pronti a masterizzare la nostra .iso

La máquina virtual de Java no conoce al operador de concatenación (+) a la hora de ejecutar nuestro código.
Por este motivo el compilador se encarga de traducir los lugares donde este operador aparece por el código necesario que permite cumplir con el mismo propósito y de forma óptima.

Veremos cuales son las traducciones realizadas por el compilador y como podemos aprovecharlas a nuestro favor.

Definiciones

Antes de empezar vamos a definir algunos términos, que aunque no sean definidos de una forma muy formal, permitirán una mejor comprensión del texto:

• Cadena: Una instancia de la clase String. El objeto puede estar asignado a una variable, una constante o no (cadenas anónimas)

• Cadenas Anónimas: Cadenas no asociadas a ningún objeto que se crean y utilizan en la sentencia que se declaran, y luego son descartadas. Por ejemplo en:

System.out.println("Hola Mundo");

la cadena “Hola Mundo” se crea y utiliza en el System.out.println y luego se descarta.

Caso 1: Concatenación de cadenas anónimas

Aunque muchas veces parezca incorrecta o ineficiente la realización de concatenación de dos cadenas anónimas en vez de solo utilizar una, resulta ser lo mismo luego de pasar por el compilador, ya que si tenemos por ejemplo:

//...
String a = "Hola " + "Mundo";
//...

Se convertirá en:

//...
String a = "Hola Mundo";
//...

Viendo la maquina virtual lo mismo que si hubiéramos asignado “Hola Mundo” de primera intención.

Cuál puede ser el beneficio entonces de separar una cadena anónima en dos o más pedazos?

El beneficio que encontramos no es al momento de correr nuestro programa, sino al momento de mantenerlo, ya que en varias ocasiones permitirá una mejor lectura del mismo:

String fragmento = "Por lo tanto, los que no son totalmente conscientes de"
+ " la desventaja de servirse de las armas no pueden ser totalmente conscientes"
+ " de las ventajas de utilizarlas";

Caso 2: Concatenación de constantes

Si tenemos definidas constantes y las concatenamos con alguna cadena anónima o entre si, primero que nada el compilador realizará el intercambio de las constantes por la cadena que representan y luego las trata como el caso anterior. Por ejemplo:

//...
public static final String CONSTANTE_A = "AAA";
private static final String CONSTANTE_B = "BBB";
public final String CONSTANTE_C = "CCC";
private final String CONSTANTE_D = "DDD";
//...
String a = "Mostrar " + CONSTANTE_A;
String b = "Mostrar " + CONSTANTE_B;
String c = "Mostrar " + CONSTANTE_C;
String d = "Mostrar " + CONSTANTE_D;
//...

Después de compilar tendremos:

//...
String a = "Mostrar AAA";
String b = "Mostrar BBB";
String c = "Mostrar CCC";
String d = "Mostrar DDD";
//...

Por lo que podemos ver que no importa el modificador de acceso o si es estática o no, mientras el valor de la constante este disponible a la hora de compilar, será reemplazado en la concatenación.

En este caso podemos ver que la ventaja que trae aparejado el uso de constantes, que es permitirnos hacer mas legible nuestro código no va en contraposición a la de la tener una buena eficiencia en la ejecución, ya que no se perderá tiempo realizando concatenaciones porque fueron realizadas al momento de la compilación.

Caso 3: Concatenación de variables finales

Al igual que en el caso anterior si tenemos definida un variable declarada dentro de un método como final y esta la concatenamos, el compilador la reemplazara la referencia por el valor que representa la variable final.

Por ejemplo:

//...
final String a = " AAA";
String b = "Mostrar " + a;
//...

Después de compilar obtendremos:

//...
final String a = " AAA";
String b = "Mostrar AAA";
//...

Otra vez tenemos las mismas ventajas del punto anterior.

Caso 4: Concatenación de variables

La concatenación de variables es distinta de los casos anteriores debido a que en ningún caso el compilador puede suponer el valor almacenado en las mismas. Como no sabe con que valores se contará, lo que se realiza a la hora de compilar es armar un StringBuilder e irle agregando las cadenas que queremos visualizar.

Esta vez la sentencia quedará preparada y la concatenación real se realizara durante el momento de ejecución.

Por ejemplo:

//...
String v = "Mundo";
//...
String resultado = "Hola " + v;
//...

Como se puede observar, no se puede asegurar de ninguna manera que el valor de “v” va a seguir siendo “Mundo” al momento de concatenar, por lo que el compilador genera:

//...
String resultado = (new StringBuilder()).append("Hola ").append(v).toString();
//...

Básicamente al ejecutarse realizará lo siguiente:

- creará una instancia de StringBuilder
- le agregará la cadena “Hola “
- le agregará el valor de la variable “v”
- obtendrá la cadena resultante
- asignará la cadena resultante a la variable “resultado”

Nuevamente lo que ganamos es expresión a la hora de analizar nuestro código. Veamos un ejemplo ilustrativo de esto, es más difícil entender a simple vista esto:

//...
String res = "Cantidad de tomates: ".concat(Integer.toString(cantidad));
//...

A esto:

//...
String res = "Cantidad de tomates: " + cantidad;
//...

Caso 5: Caso especial de concatenación de variables

Existe un caso especial a la hora de realizar optimizaciones que el compilador no es capaz de darse cuenta, cuando a una variable debemos concatenarle cadenas en varias sentencias, por ejemplo un caso muy simple:

//...
String e = "Hola";
for (int i = 0; i < 100; i++) {
     e += " mundo";
}
//...

En este caso el código generado será el siguiente:

//...
String e = "Hola";
for (int i = 0; i < 100; i++){
     e = (new StringBuilder()).append(e).append(" mundo").toString();
}
//...

Por lo tanto cada nueva iteración del bucle lleva aparejado la creación de un StringBuilder para agregarles las cadenas y asignárselo a la variable “e”

Lo que se puede realizar es crear un StringBuilder e irlo asignando en cada iteración, de la forma:

//...
StringBuilder sb = new StringBuilder("Hola");
for (int i = 0; i < 100; i++) {
     sb.append(" mundo");
}
String e = sb.toString();
//...

Entonces la ejecución se resume a:

- creará una instancia de StringBuilder con el texto inicial (“Hola”)
- le agregará la cadena “ mundo“ una vez por cada bucle
- obtendrá la cadena resultante
- asignará la cadena resultante a la variable “e”

Como pudimos ver en un post anterior la principal ventaja es la gran cantidad de tiempo ganado durante la ejecución.

Conclusión

Como pudimos ver a lo largo de estos casos es que es importante saber como el compilador hace las cosas para de esa forma poder preocuparnos más en el diseño/mantenimiento de nuestras aplicaciones a estar optimizando código que optimizara el compilador y que visualmente es difícil de comprender.

Si es eficiente y bello, no se puede pedir más.

Nota Final

Todo el análisis realizado sobre el funcionamiento del compilador a partir del código generado por el mismo, fue realizado utilizando Jad para descompilar los .class

En el post anterior hablamos como integrar Jad a NetBeans mediante NBJAD.

Es muy bueno el ejercicio de generar clases y analizar que optimizaciones realizo el compilador, ayudándonos esto a tener una base más amplia donde apoyarnos a la hora de desarrollar.

Espero les sirva.
Saludos.

Más Info

• Optimización al concatenar Strings en Java

• Integrar Jad a NetBeans mediante NBJAD

In the PC world, you would use HJSplit to join and recombine them.

For Mac OS X, you’ll use Split&Concat to do it instead.

You can also use Split&Concat to split a large file. The resulting files are 100% HJSplit compatible.

Al momento de concatenar cadenas, Java ofrece varios métodos de realizar el proceso, pero el rendimiento obtenido entre cada una de estas formas puede ser totalmente diferente.

Veremos cuales son las formas más optimas de realizar esto según cada circunstancia.

Existen 3 maneras de realizar este proceso:

1. Concatenando mediante el operador +
2. Concatenando mediante la funcion concat() de la clase String
3. Utilizando la clase StringBuffer

Para realizar la comparación de rendimientos de cada método utilizaremos un algoritmo simple donde se utiliza cada una de las técnicas, y para el análisis nos valdremos del análisis del Profiler de NetBeans.

package testcadena;
public class Main {
     private static final int cantidadPrueba = 10000;

     public static void main(String[] args) {
         concatenacionBString();
         concatenacionConcat();
         concatenacionSuma();
     }

     private static void concatenacionSuma() {
         String resultado = "inicio";
         for (int i = 0; i < cantidadPrueba; i++) {
             resultado += " hola";
         }
     }

     private static void concatenacionConcat() {
         String resultado = "inicio";
         for (int i = 0; i < cantidadPrueba; i++) {
             resultado.concat(" hola");
         }
     }

     private static void concatenacionBString() {
         StringBuffer resultado = new StringBuffer("inicio");
         for (int i = 0; i < cantidadPrueba; i++) {
             resultado.append(" hola");
         }
     }
}

Mediante la constante cantidadPrueba iremos variando la cantidad de concatenaciones que se realizaran.

Concatenando 1000 cadenas

Realizando la prueba con cantidadPrueba=1000 vemos que el Profiler nos indica:

Podemos apreciar que el método que utiliza StringBuffer es el más rápido, seguido por el que utiliza concat y por último (más de 100 veces más lento que los anteriores) el método utilizando el operador “+”.

Concatenando 100 cadenas

Bajamos la cantidad de concatenaciones hechas para verificar que pasa:

Ahora el más rápido es concat seguido de cerca por StringBuffer, pero el operador de concatenación sigue siendo el más lento (aunque ahora la diferencia ya no es tan grande como en la prueba anterior)

Concatenando 10 cadenas

Seguimos bajando la cantidad de concatenaciones:

Ahora se mantiene y acentúa la tendencia de la anterior prueba, siendo concat el más rápido.

Concatenando 1 cadena

Realizamos la prueba menor, concatenandole a la cadena inicial solo una cadena.

Como era de esperar sigue siendo más rápido la solución con concat, pero ahora es más rápido la suma antes que el uso de StringBuffer (esto es debido al costo propio de crear el Buffer para la cantidad de concatenaciones realizadas)

Conclusión

De este pequeño análisis podemos obtener las siguientes conclusiones:

• Nunca es optimo realizar una concatenación de clases mediante el operador de concatenación (+)
• Para un pequeño número de concatenaciones es mejor utilizar el método concat() de la clase String
• Para gran cantidad de concatenaciones sobre una cadena, lo mejor es utilizar un StringBuffer

StringBuilder vs. StringBuffer

Agregado el 18 de Marzo de 2008:

Un cuarto método de concatenar String es usando la clase StringBuilder.

StringBuilder tiene una funcionalidad similar a la de StringBuffer, pero la principal diferencia radica en que StringBuilder no está preparada para acceso concurrente tal como lo hace StringBuffer.

Esto puede parecer una desventaja, si usamos múltiples hilos insertando sobre la misma secuencia de caracteres deberemos utilizar obligadamente StringBuffer. Sin embargo encontraremos que en la mayoría de los casos solo un hilo accede a la secuencia de caracteres, siendo todos los mecanismos de sincronización utilizados por StringBuffer completamente inútiles, siendo en estos casos StringBuilder la solución ideal.

Como vimos en los ejemplos anteriores, el StringBuffer es utilizado y consumido por un mismo hilo (el hilo que ejecuta el método), por lo cual esta es una situación ideal para reemplazar StringBuffer por StringBuilder

Creamos un nuevo método:

...
    private static void concatenacionBBuilder() {
        StringBuilder resultado = new StringBuilder("inicio");
        for (int i = 0; i < cantidadPrueba; i++) {
            resultado.append(" hola");
        }
    }
...

y comparamos este método con el que utilizaba StringBuffer, obteniendo:

pudiendo de esta forma comprobar que se ha obtenido una pequeña optimizacion, que era nuestro objetivo.

Ganando más performance

Agregado el 07 de Mayo de 2008:

Si sabemos (o sospechamos por lo menos) cuanto crecerá nuestro StringBuilder ó StringBuffer podemos indicarselo al construirlos.

El problema es que cada vez que hacemos un append() debe crecer antes de copiar la cadena.

Creamos un método nuevo para probar esto:

...
    private static void concatenacionBBuilder2() {
        StringBuilder resultado = new StringBuilder(6*cantidadPrueba);

        resultado.append("inicio");
        for (int i = 0; i < cantidadPrueba; i++) {
            resultado.append(" hola");
        }
    }
...

y estos son los resultados:

Por lo que si tenemos alguna forma de predecir cuanto crecerá, esto es importante tenerlo en cuenta.

Más Info

• Concatenación de cadenas en Java: Optimizaciones realizadas por el compilador
• Javadoc StringBuilder
• Javadoc StringBuffer
• Optimization of String Concatenation