Korrekten Verwendung von StringBuilder-Objekt in SQL

Dem Ziel der Verwendung von StringBuilder, ich.e reduzieren von Speicher. Wird es erreicht?

Nein, überhaupt nicht. Dieser code wird nicht mit StringBuilder richtig. (Ich glaube, du hast falsch zitiert es, aber sicherlich gibt es nicht in Anführungszeichen id2 und table?)

Beachten Sie, dass das Ziel (in der Regel) zu reduzieren, - Speicher churn eher als der gesamte Speicher genutzt, um das Leben ein bisschen einfacher auf den garbage collector.

Wird, dass der Speicher gleich mit String wie unten?

Nein, es werden Ursache mehr Speicher Abwanderung als nur die gerade concat, die Sie verstehen. (Bis/es sei denn, der JVM-Optimierer sieht, dass das explizite StringBuilder im code ist überflüssig und optimiert es aus, wenn man es kann.)

Wenn der Autor des Codes verwenden will StringBuilder (es gibt Argumente für, aber auch gegen; siehe Hinweis am Ende dieser Antwort), besser, es richtig zu machen (hier gehe ich davon aus dass es eigentlich nicht in Anführungszeichen id2 und table):

StringBuilder sb = new StringBuilder(some_appropriate_size);
sb.append("select id1, ");
sb.append(id2);
sb.append(" from ");
sb.append(table);
return sb.toString();

Beachten Sie, dass ich aufgeführt habe some_appropriate_size im StringBuilder Konstruktor, so dass es beginnt, mit genug Kapazität für den gesamten Inhalt, den wir gehen, zum Anhängen. Die default-Größe verwendet, wenn Sie nicht angeben, ist 16 Zeichen, die in der Regel zu klein und die Ergebnisse in die StringBuilder sich nicht um die Umschichtungen selbst zu machen, größer (wenn ich mich Recht erinnere, in der Sun/Oracle-JDK, verdoppelt sich [oder mehr, wenn es weiß, braucht es mehr, um einen bestimmten append] jedes mal, es läuft aus dem Zimmer).

Können Sie gehört haben, dass die string-Verkettung wird Verwendung eines StringBuilder unter der Decke, wenn kompiliert mit Sun/Oracle-compiler. Das ist wahr, es wird mit einer StringBuilder für den gesamten Ausdruck. Aber es wird der Standard-Konstruktor, was bedeutet, dass in der Mehrzahl der Fälle wird es um eine Umverteilung. Es ist leichter zu Lesen, obwohl. Beachten Sie, dass dies nicht von einer echten Serie von Verkettungen. So zum Beispiel, nutzt diese eine StringBuilder:

return "prefix " + variable1 + " middle " + variable2 + " end";

Es übersetzt in etwa:

StringBuilder tmp = new StringBuilder(); //Using default 16 character size
tmp.append("prefix ");
tmp.append(variable1);
tmp.append(" middle ");
tmp.append(variable2);
tmp.append(" end");
return tmp.toString();

So, dass ist okay, auch wenn die Standard-Konstruktor und anschließende Umverteilung(s) ist nicht ideal, sind die Chancen, es ist gut genug — und die Verkettung ist ein viel mehr lesbar.

Aber das ist nur für einen einzigen Ausdruck. Mehrere StringBuilders werden verwendet:

String s;
s = "prefix ";
s += variable1;
s += " middle ";
s += variable2;
s += " end";
return s;

Dass am Ende immer so etwas wie dieses:

String s;
StringBuilder tmp;
s = "prefix ";
tmp = new StringBuilder();
tmp.append(s);
tmp.append(variable1);
s = tmp.toString();
tmp = new StringBuilder();
tmp.append(s);
tmp.append(" middle ");
s = tmp.toString();
tmp = new StringBuilder();
tmp.append(s);
tmp.append(variable2);
s = tmp.toString();
tmp = new StringBuilder();
tmp.append(s);
tmp.append(" end");
s = tmp.toString();
return s;

...das ist ziemlich hässlich.

Es ist wichtig zu beachten Sie jedoch, dass in allen, aber ganz wenigen Fällen es egal und gehen mit der Lesbarkeit (das erhöht die Wartbarkeit) wird bevorzugt, abgesehen von einer spezifischen performance-Problem.

[[ Es gibt einige gute Antworten hier, aber ich finde, dass Sie immer noch fehlt ein bisschen information. ]]

return (new StringBuilder("select id1, " + " id2 " + " from " + " table"))
     .toString();

So wie Sie, das Beispiel, das Sie geben, ist eine einfache, aber analysieren wir es trotzdem. Was hier passiert, ist die compiler eigentlich die + Arbeit hier, weil "select id1, " + " id2 " + " from " + " table" sind alle Konstanten. Also diese verwandelt sich in:

return new StringBuilder("select id1,  id2  from  table").toString();

In diesem Fall, es gibt natürlich keinen Punkt in mit StringBuilder. Sie könnten das auch tun:

//the compiler combines these constant strings
return "select id1, " + " id2 " + " from " + " table";

Jedoch, auch wenn man anfügen von beliebigen Feldern oder anderen nicht-Konstanten, dann würde der compiler die Verwendung einer internen StringBuilder -- es gibt keine Notwendigkeit für Sie zu definieren:

//an internal StringBuilder is used here
return "select id1, " + fieldName + " from " + tableName;

Unter der Decke, diese verwandelt sich in code, entspricht etwa:

StringBuilder sb = new StringBuilder("select id1, ");
sb.append(fieldName).append(" from ").append(tableName);
return sb.toString();

Wirklich die einzige Zeit, die Sie brauchen, um zu verwenden StringBuilder direkt ist, wenn Sie bedingten code. Für Beispiel-code, der wie folgt aussieht ist verzweifelt für eine StringBuilder:

//1 StringBuilder used in this line
String query = "select id1, " + fieldName + " from " + tableName;
if (where != null) {
   //another StringBuilder used here
   query += ' ' + where;
}

Den + in der ersten Zeile verwendet man StringBuilder Instanz. Dann die += verwendet eine andere StringBuilder Instanz. Es ist effizienter, das zu tun:

//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();

Einem anderen Zeitpunkt, ich benutze eine StringBuilder ist, wenn ich Baue einen string aus einer Reihe von Methodenaufrufen. Dann kann ich Methoden erstellen, nehmen Sie eine StringBuilder argument:

private void addWhere(StringBuilder sb) {
   if (where != null) {
      sb.append(' ').append(where);
   }
}

Wenn Sie eine StringBuilder, Sie sollten sehen in der Verwendung von + zur gleichen Zeit:

sb.append("select " + fieldName);

Dass + wird dazu führen, eine andere interne StringBuilder erstellt werden. Dies sollte selbstverständlich sein:

sb.append("select ").append(fieldName);

Schließlich ist, wie @T. J. rowder Punkte aus, sollten Sie immer stellen Sie eine Vermutung an, die Größe der StringBuilder. Das spart auf die Anzahl der char[] erstellte Objekte bei der wachsenden Größe der internen Puffer.

In dem code, den Sie gepostet haben es wäre keine Vorteile, da Sie missbräuchlich die StringBuilder. Sie bauen die gleiche Zeichenfolge in beiden Fällen. Mit StringBuilder können Sie vermeiden, die + Betrieb auf Strings mit der append Methode.
Sie sollten diese Art der Nutzung:

return new StringBuilder("select id1, ").append(" id2 ").append(" from ").append(" table").toString();

In Java der Typ String ist ein inmutable Folge von Zeichen, so dass, wenn man zwei Saiten mit der VM erstellt eine neue Zeichenfolge mit beiden Operanden verkettet.

StringBuilder bietet eine veränderbare Abfolge von Zeichen, die Sie verwenden können, um concat verschiedene Werte oder Variablen ohne neue String-Objekte, und so kann es manchmal effizienter sein als das arbeiten mit strings

Dieser bietet einige nützliche Funktionen, wie das ändern der Inhalt einer char-Sequenz als parameter übergeben, die innerhalb einer anderen Methode, die Sie kann nicht mit Strings.

private void addWhereClause(StringBuilder sql, String column, String value) {
   //WARNING: only as an example, never append directly a value to a SQL String, or you'll be exposed to SQL Injection
   sql.append(" where ").append(column).append(" = ").append(value);
}

Weitere Infos unter http://docs.oracle.com/javase/tutorial/java/data/buffers.html