[[Il y a de bonnes réponses ici, mais je trouve qu'elles manquent encore d'un peu d'informations. ]]
return (new StringBuilder("select id1, " + " id2 " + " from " + " table"))
.toString();
Donc, comme vous le faites remarquer, l'exemple que vous donnez est simpliste mais analysons-le quand même. Ce qui se passe ici, c'est que le compilateur fait réellement le +
travail ici car ce "select id1, " + " id2 " + " from " + " table"
sont toutes des constantes. Donc, cela se transforme en:
return new StringBuilder("select id1, id2 from table").toString();
Dans ce cas, évidemment, il ne sert à rien d'utiliser StringBuilder
. Vous pourriez aussi bien faire:
// the compiler combines these constant strings
return "select id1, " + " id2 " + " from " + " table";
Cependant, même si vous ajoutiez des champs ou d'autres non-constantes, le compilateur utiliserait un interne StringBuilder
- vous n'avez pas besoin d'en définir un:
// an internal StringBuilder is used here
return "select id1, " + fieldName + " from " + tableName;
Sous les couvertures, cela se transforme en code qui équivaut à peu près à:
StringBuilder sb = new StringBuilder("select id1, ");
sb.append(fieldName).append(" from ").append(tableName);
return sb.toString();
Vraiment, le seul moment où vous devez utiliser StringBuilder
directement est lorsque vous avez du code conditionnel. Par exemple, un code qui ressemble à ce qui suit est désespéré pour un StringBuilder
:
// 1 StringBuilder used in this line
String query = "select id1, " + fieldName + " from " + tableName;
if (where != null) {
// another StringBuilder used here
query += ' ' + where;
}
Le +
dans la première ligne utilise une StringBuilder
instance. Ensuite, +=
utilise une autre StringBuilder
instance. Il est plus efficace de faire:
// choose a good starting size to lower chances of reallocation
StringBuilder sb = new StringBuilder(64);
sb.append("select id1, ").append(fieldName).append(" from ").append(tableName);
// conditional code
if (where != null) {
sb.append(' ').append(where);
}
return sb.toString();
Une autre fois que j'utilise a, StringBuilder
c'est lorsque je construis une chaîne à partir d'un certain nombre d'appels de méthode. Ensuite, je peux créer des méthodes qui prennent un StringBuilder
argument:
private void addWhere(StringBuilder sb) {
if (where != null) {
sb.append(' ').append(where);
}
}
Lorsque vous utilisez a StringBuilder
, vous devez surveiller toute utilisation de +
en même temps:
sb.append("select " + fieldName);
Cela +
entraînera la StringBuilder
création d' un autre interne . Cela devrait bien sûr être:
sb.append("select ").append(fieldName);
Enfin, comme le souligne @TJrowder, vous devez toujours deviner la taille du fichier StringBuilder
. Cela permettra d'économiser sur le nombre d' char[]
objets créés lors de l'augmentation de la taille du tampon interne.
PreparedStatement
ou quelque chose de similaire: docs.oracle.com/javase/tutorial/jdbc/basics/prepared.html