About Performance Tuning in java

Question

What good ways to improve performance of code that uses lot of strings?

Answer 1

Use appropriate data structures and algorithms.
[url http://java.sun.com/developer/technicalArticles/Interviews/devinsight_1/]Write dumb code.
Don't worry about microoptimizations, and don't look for "clever tricks."
Don't assume something will be "slow" and then write fugly code to "fix" it. Write clean, simple code using standard idioms, test it, and if it doesn't meet your performance requirements, profile it to find where the bottleneck is, and once you find and fix that, test and profile again to see if the fix actually made a significant improvement. If it didn't, and the new code is not at least as clean as the old, then revert it back to the previous code.
All of the above advice applies for all Java coding, not just String-heavy cases.
The only semi-major String-specific performance/memory techniques that come up are as follows. And they don't really matter all that often in the real world:
1. When building up a String in a loop, if the pieces are large or if there are many pieces, use StringBuilder or StringBuffer's append() method, not direct String concatenation with plus-equal.
// do this
String s;
StringBuilder sb = new StringBuilder();
while (...) {
  sb.append(something);
s = sb.toString();
// not this
String s = "";
while (...) {
  s += something;
  // or
  s = s + something;The reason for this is that with the second approach, every time through the loop we create a new String object and copy all the characters over from the previous one. The first approach just keeps adding characters to the end of the existing StringBuilder.
However, this really only makes a practical difference if the pieces are very large, or if there are a lot of them.
Also note that String s = "a" + b + "c" + d; is fine, because the compiler turns those into append() calls anyway.
2. Use new String() when taking a small substring of a large String, if the small one will be kept around much longer than the larger original.
// do this
String s1 = a_very_large_string;
String s2 = new String(s1.substring(5, 7));
// not this
String s1 = a_very_large_string;
String s2 = s1.substring(5, 7);The reason for this is that substring uses the same backing array as the original. If we're done using the large String, that String object itself may become eligible for GC, but the large backing array will be kept around as long as the smaller String is alive. In this case, we're wasting most of its space for just a few characters. However, when we do new String(), that creates a new String object with its own backing array of just the characters that are part of that String, so once the original goes away, its large backing array can go with it.
If the strings are of about the same scale, or if they're both small or even only "sort of large," this will not be an issue. Also, if both of the Strings' lifetimes end at about the same time, it won't be an issue.
Again, though, don't overdo it. Pay close attention to the cases I described where these techniques don't matter.
Edited by: jverd on Oct 6, 2010 10:08 PM
Edited by: jverd on Oct 6, 2010 10:10 PM
Edited by: jverd on Oct 6, 2010 10:21 PM