Surrounding Scala Strings - string

Question

If you do something in a single statement like "abc" + stringval + "abc", is that one immutable string copy, or two (noting that abc and 123 are constant at compile time)
Bonus round: would using a StringBuilder like the following have more or less overhead?
def surround(s:String, ss:String):String = {
val surrounded = new StringBuilder(s.length() + 2*ss.length(), s)
surrounded.insert(0,ss)
surrounded.append(ss)
surrounded.mkString
}
Or is there a more idiomatic way that I'm unaware of?

Answer 1

It has less overhead than concatenation. But the insert in your example is not efficient. The following is a little cleaner and uses only appends for efficiency.
def surround(s:String, ss:String) =
new StringBuilder(s.length() + 2*ss.length(), ss).append(s).append(ss).mkString

Answer 2

My first impulse is to look at the bytecode and see. So,
// test.scala
object Comparison {
def surround1(s: String, ss: String) = {
val surrounded = new StringBuilder(s.length() + 2*ss.length(), s)
surrounded.insert(0, ss)
surrounded.append(ss)
surrounded.mkString
}
def surround2(s: String, ss: String) = ss + s + ss
def surround3(s: String, ss: String) = // Neil Essy
new StringBuilder(s.length() + 2*ss.length(), ss).append(s).append(ss).mkString
}
and then:
$ scalac -optimize test.scala
$ javap -verbose Comparison$
[... lots of output ...]
Roughly, Neil Essy's and yours are identical but for the one method call (and some stack noise). surround2 is compiled into something like
val sb = new StringBuilder()
sb.append(ss)
sb.append(s)
sb.append(ss)
sb.toString
I'm new to Scala (and Java), so I don't know how generally useful it is to look at the bytecode -- but it tells you what this scalac does with this code.

Answer 3

Doing a little testing on this in Java and now in Scala the value of using a StringBuilder is questionable unless you are doing a lot of appending of non-constant strings.
object AppendTimeTest {
val tries = 500000
def surround(s:String, ss:String) = {
(1 to tries).foreach(_ => {
new StringBuilder(s.length() + 2*ss.length(), ss).append(s).append(ss).mkString
})
val start = System.currentTimeMillis()
(1 to tries).foreach(_ => {
new StringBuilder(s.length() + 2*ss.length(), ss).append(s).append(ss).mkString
})
val stop = System.currentTimeMillis()
val delta:Double = stop -start
println("Total time: " + delta + ".\n Avg. time: " + (delta/tries))
}
def surroundStatic(s:String) = {
(1 to tries).foreach(_ => {
"ABC" + s + "ABC"
})
val start = System.currentTimeMillis()
(1 to tries).foreach(_ => {
"ABC" + s + "ABC"
})
val stop = System.currentTimeMillis()
val delta:Double = stop -start
println("Total time: " + delta + ".\n Avg. time: " + (delta/tries))
}
}
Calling this a few times in the interpreter yields:
scala> AppendTimeTest.surroundStatic("foo")
Total time: 241.0.
Avg. time: 4.82E-4
scala> AppendTimeTest.surround("foo", "ABC")
Total time: 222.0.
Avg. time: 4.44E-4
scala> AppendTimeTest.surroundStatic("foo")
Total time: 231.0.
Avg. time: 4.62E-4
scala> AppendTimeTest.surround("foo", "ABC")
Total time: 247.0.
Avg. time: 4.94E-4
So unless you are appending many different non-constant strings I believe you won't see any big difference in performance. Alsol concatenating constants (i.e. "ABC" + "foo" + "ABC") is as you probably know handled by the compiler (this is atleast the case in Java, but I believe it's also holds true for Scala)

Answer 4

Scala is pretty close to java for string manipulation. Your example:
val stringval = "bar"
"abc" + stringval + "abc"
actually ends up (in java style) as:
(new StringBuilder()).append("abc").append(stringval()).append("abc").toString()
This is the same behaviour as java, + between strings are generally translated to instances of StringBuilder, which are more efficient. So here, you're doing three copies to the StringBuilder, and one final String creation, and depending upon the length of the strings, potentially three reallocations.
In your example:
def surround(s:String, ss:String):String = {
val surrounded = new StringBuilder(s.length() + 2*ss.length(), s)
surrounded.insert(0,ss)
surrounded.append(ss)
surrounded.mkString
}
you're doing the same number of copies (3) but you're only allocating once.
Advice: If the strings are small, use +, it makes very little difference. If the strings are relatively large, then initialise the StringBuilder with the relevant length, but then simply append. This is much clearer for the other developers.
As always with performance, measure it, and if the differences are small, use the simpler solution

Answer 5

Generally in Java / Scala, String literals in source code are interned for efficiency, which means that all copies of it in your code will refer to the same object. So there will only be one "copy" of "abc".
Java and Scala don't have "constants" like in C++. Variables initialised with val are immutable, but in the general case vals from one instance to the next are not the same (specified via constructor).
So in theory the compiler could check for simple cases where the val will always initialise the same value and optimise accordingly, but it would add extra complicaton. And you could just optimise it yourself by writing it as "abc123abc".
Others have already addressed your bonus question.

Answer 6

You can also use mkString on a String.
def surround(s:String, ss:String) = s.mkString(ss, "", ss)
Internally it is using StringBuilder too, but I like the way it reads.
I would maybe just even inline it.