StringBuilder vs Chaîne envisage de remplacer

Devinez quoi? Si vous êtes en cours d'exécution avec Java 1.5+ la concaténation fonctionne de la même façon avec les littéraux de chaîne

  String h = "hello" + "world";

et

  String i = new StringBuilder().append("hello").append("world").toString();

Sont les mêmes.

Ainsi, le compilateur a fait le travail pour vous déjà.

Bien sûr, il vaut mieux serait de:

 String j = "hellworld"; //;) 

Que pour le second, yeap, c'est préférable, mais devrait pas être difficile, avec la puissance de "rechercher et remplacer" et un peu de regex foo

Par exemple, vous pouvez définir une méthode comme dans cet exemple:

  public static void replace( String target, String replacement, 
                              StringBuilder builder ) { 
    int indexOfTarget = -1;
    while( ( indexOfTarget = builder.indexOf( target ) ) >= 0 ) { 
      builder.replace( indexOfTarget, indexOfTarget + target.length() , replacement );
    }
  }

Et votre code ressemble à ceci:

someString = someString.replace("VARIABLE1", "abc");
someString = someString.replace("VARIABLE2", "xyz");

Tout ce que vous avez à faire est de saisir éditeur de texte, un déclencheur de quelque chose comme ce vi de recherche et de remplacement:

%s/^.*("\(.*\)".\s"\(.*\)");/replace("","",builder);

Lire: "prendre quelque chose dans la parenthèse et qui ressemble à une chaîne littérale, et de le mettre dans cette autre chaîne".

Et votre code va chercher à partir de ce:

someString = someString.replace("VARIABLE1", "abc");
someString = someString.replace("VARIABLE2", "xyz");

à ceci:

replace( "VARIABLE1", "abc", builder );
replace( "VARIABLE2", "xyz", builder );

En un rien de temps.

Voici un travail de démonstration:

class DoReplace { 
  public static void main( String ... args ) {
    StringBuilder builder = new StringBuilder(
       "LONG CONSTANT WITH VARIABLE1 and  VARIABLE2 and VARIABLE1 and VARIABLE2");
    replace( "VARIABLE1", "abc", builder );
    replace( "VARIABLE2", "xyz", builder );
    System.out.println( builder.toString() );
  }
  public static void replace( String target, String replacement, 
                              StringBuilder builder ) { 
    int indexOfTarget = -1;
    while( ( indexOfTarget = builder.indexOf( target ) ) > 0 ) { 
      builder.replace( indexOfTarget, indexOfTarget + target.length() , 
                       replacement );
    }
  }
}

Au lieu d'avoir de longues lignes comme ça, vous pouvez simplement écrire une méthode de remplacement de pièces de StringBuilder chaînes, quelque chose le long des lignes de ce:

public StringBuilder replace(StringBuilder someString, String replaceWhat, String replaceWith) {
   return someString.replace(someString.indexOf(replaceWhat), someString.indexOf(replaceWhat)+replaceWhat.length(), replaceWith);
}

Si votre chaîne est vraiment grand et vous êtes inquiet au sujet de la performance, je recommanderais l'écriture d'une classe qui prend votre modèle de texte et une liste de variables, puis lit plus la source de la chaîne caractère par caractère et construit le résultat à l'aide de StringBuilder. Que devrait être la plus efficace à la fois en termes de CPU et de la mémoire. Aussi, si vous êtes la lecture de ce texte du modèle à partir d'un fichier que je n'aurais pas de charge tout en mémoire à l'avant. Processus dans des morceaux comme vous le lire à partir du fichier.

Si vous êtes à la recherche d'un moyen agréable de générer une chaîne qui n'est pas tout à fait aussi efficace que StringBuilder mais plus efficace que d'ajouter des chaînes plus et plus vous pouvez utiliser Chaîne de caractères.format(). Il fonctionne comme sprintf() en C. MessageFormat.format() est une option aussi, mais il utilise StringBuffer.

Il y a une autre question qui se pose ici: L'insertion d'une Java chaîne dans une autre chaîne sans concaténation?

Confiture de Hong-à juste titre - les solutions ci-dessus contiennent tous le potentiel pour faire une boucle à l'infini. Je suppose que la leçon à emporter ici est que les micro-optimisations peuvent souvent causer toutes sortes d'horribles problèmes et ne pas vraiment vous sauver beaucoup. Toujours, quoi qu'il en soit, voici une solution qui ne sera pas de boucle infinie.

private static void replaceAll(StringBuilder builder, String replaceWhat, String replaceWith){
    int occuranceIndex = builder.indexOf(replaceWhat);
    int lastReplace = -1;
    while(occuranceIndex >= 0){
        if(occuranceIndex >= lastReplace){
            builder.replace(occuranceIndex, occuranceIndex+replaceWhat.length(), replaceWith);
            lastReplace = occuranceIndex + replaceWith.length();
            occuranceIndex = builder.indexOf(replaceWhat);
        }else{
            break;
        }
    }
}