i wonder if this code that using StringBuilder is best efficient
or it still creating alot of temporry strings by concatenating the " " with current item?
if so can you suggest for better code?
public String toString() {
StringBuilder out = new StringBuilder();
for (long item : someListOfNumbers) {
out.append( " " + item);
}
return out.toString();
}
For this particular use case you probably want to use StringJoiner, unless your goal is to have a leading space in the result.
public String toString() {
StringJoiner joiner = new StringJoiner(" ");
someListOfNumbers.forEach(l -> joiner.add(Long.toString(l)));
return joiner.toString();
}
or use Collectors.joining():
public String toString() {
returns someListOfNumbers.stream()
.map(String::valueOf)
.collect(Collectors.joining(" "));
}
StringBuilder will be a more efficient when building the text but one can argue that above is more readable. Definitely one should avoid + operator when using StringBuilder and use methods like append() instead.
If you take a look at this or this or other answers you will see that String concatenation is additionally optimized by the javac compiler e.g. if constants are concatenated with + operator then the compiler can insert the resulting constant into bytecode.
out.append( " " + item);
In above statement there seems a problem here " " + item as its combining string with a long. As string is immutable so + operator for string creates a new copy of String in memory. An optimal solution could be using
out.append(' ').append(item);
Or even
out.append(" ").append(item);
In the both above scenarios, as StringBuilder is Mutable so extra memory space is not require to save new concatinated string. Hence its more optimal.
A modern way would leave the manipulation of the string builder to a library method:
public String toString() {
return someListOfNumbers.stream()
.map(Number::toString)
.collect(Collectors.joining(" "));
}
I have assumed that someListOfNumbers is a List<Long>. My method doesn’t give the exact same result as yours: Your result has a leading space that I have left out. If you need that space, you may either prepend it yourself or use:
.collect(Collectors.joining(" ", " ", ""));
The three-arg joining expects delimiter, prefix and suffix in the mentioned order (I am giving the empty string as suffix).
Side note: I had wanted to use .map(Long::toString), but it doesn’t compile because it is ambiguous. Here toString may refer to either the no-arg Long.toString or to the static one-arg Long.toString(long). I solved it referring to it via the superclass of Long: Number::toString. Another solution would be .map(String::valueOf) as in Karol Dowbecki’s answer.
In order to get rid of a trailing or leading zero, you have to check the index of the item that is currently handled in the loop.
Here are three examples which build a String that does not have anything to trim afterwards:
public String toString() {
StringBuilder out = new StringBuilder();
// iterate in a classic for-loop checking for item at index 0
for (int i = 0; i < someListOfNumbers.size(); i++) {
long item = someListOfNumbers.get(i);
if (i == 0) {
// in this case, avoid a leading zero
out.append(item);
} else {
out.append(" ").append(item);
}
}
return out.toString();
}
public String toString() {
StringBuilder out = new StringBuilder();
// iterate in a classic for-loop checking for item at last index
for (int i = 0; i < someListOfNumbers.size(); i++) {
long item = someListOfNumbers.get(i);
if (i == someListOfNumbers.size() - 1) {
out.append(item).append(" ");
} else {
// this case avoids a trailing zero
out.append(item);
}
}
return out.toString();
}
public String toString() {
StringBuilder out = new StringBuilder();
// add the first element and iterate from 1 to end afterwards
// (this requires a check for an empty list)
out.append(someListOfNumbers.get(0));
for (int i = 1; i < someListOfNumbers.size(); i++) {
out.append(" ").append(someListOfNumbers.get(i));
}
return out.toString();
}
You could even use you own method, but with an enhanced for-loop, you would have to use indexOf and then perform the check. I wouldn't want that, but it is your decision.
