Forum:

Performance

String Vs StringBuffer

Krishna Srinivasan

Ranch Hand

Posts: 1880

I like...

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

HI,
Here i am facing some performance difference with String and StringBuffer.
Firts i tried using StringBuffer, execution time difference is 0 secods...that means its fast..but i tried using String class ...it gives 10 mili seconds diff in execution of the loop.....but its only the first time i am execting the program...second time its execute within 0 mili seconds .......
what is the reason ??

Sample.java
=========

DateFormat.java
===========

[added code tags - Ilja]
[ June 25, 2004: Message edited by: Ilja Preuss ]

Whizlabs Support ([email protected] or +91-9971838640 )
OCAJP 8 | OCPJP 8 | OCEJWCD | OCMJEA

Gian Franco

blacksmith

Posts: 979

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

Hi,

How many times did you try this out,
do you have a representative amount
of test runs?

Cheers,

Gian Franco

ps I'm afraid this topic will be
moved from this forum

[ June 25, 2004: Message edited by: Gian Franco Casula ]

"Eppur si muove!"

Barry Gaunt

Ranch Hand

Posts: 7729

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

Right on. Moving to... Damn it. It's already here!
[ June 25, 2004: Message edited by: Barry Gaunt ]

Ask a Meaningful Question and HowToAskQuestionsOnJavaRanch
Getting someone to think and try something out is much more useful than just telling them the answer.

Jeanne Boyarsky

author & internet detective

Posts: 42237

943

I like...

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

In Windows, Java can only measure times 10 millis apart. Try putting the code in a loop and run it 100 times. Then you will get times you can compare.

[OCP 21 book] | [OCP 17 book] | [OCP 11 book] | [OCA 8 book] [OCP 8 book] [Practice tests book] [Blog] [JavaRanch FAQ] [How To Ask Questions] [Book Promos]
Other Certs: SCEA Part 1, Part 2 & 3, Core Spring 3, TOGAF part 1 and part 2

Java 8 (verified skill)
Skill verified by Jeanne Boyarsky

JUnit 5 (verified skill)
Skill verified by Jeanne Boyarsky

Kris Philippaerts

Greenhorn

Posts: 25

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

Don't forget, the java specification states that String concatenation will be optimized (where possible) by using StringBuffers. So, the performance of both pieces of code might be equal... You should first try to compile both pieces of code, and then decompile it, and see if the decompiled code still works with Strings.

Second, you should never trust time measurement under, say, 100ms on Windows. As stated before, try to run your test 100 times, or even 1000 times in a loop, and compare the total times.

Kris Philippaerts

Greenhorn

Posts: 25

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

I know, this thread might be dead allready, but what the heck I tried it out for you. I ran both implementations 100,000 times and measured the time needed for this. The String implementation took 1.482 seconds to complete. The StringBuffer implementation took no more than 270 milli seconds to complete. This is more than 5 times faster than the String implementation.

Ilja Preuss

author

Posts: 14112

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

Thank you very much!

Can you show us the benchmark code?

Also, what JDK did you run this on? This might heavily affect performance differences.

The soul is dyed the color of its thoughts. Think only on those things that are in line with your principles and can bear the light of day. The content of your character is your choice. Day by day, what you do is who you become. Your integrity is your destiny - it is the light that guides your way. - Heraclitus

clio katz

Ranch Hand

Posts: 101

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

in all of the performance doc i have read, StringBuffer is (almost) always recommended over String ... particularly for operations involving string concatenation

to wit

Adding on to a StringBuffer is [also] quite a bit faster than the + operator, which creates a new StringBuffer itself, appends both of the arguments, and converts the result back to a String

- patrick.net

some other linx

Glen McCluskey et al
Hardwick's Java Optimization site

[these sites also have additional embedded links as well]

hth

Jim Yingst

Wanderer

Posts: 18671

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

in all of the performance doc i have read, StringBuffer is (almost) always recommended over String

Well not really. However in cases where String + is faster, it's usually a very minor difference. In cases where StringBuffer is faster, it may be much, much faster. Adding N things to a StringBuffer is an O(N) operation. Adding them to a String via concatenation can be an O(N^2) operation. Which is a Bad Thing™ if N is big.

A good general rule of thum is: if you're adding to a stringlike thingy inside a loop, and the thingy gets bigger each time - use a StringBuffer. Otherwise, use String coincatenation with the + sign. The difference in performance is minor, and the + is usually more readable.

For what it's worth, if you can build up the entire String in one line, no loop, then the + will generally be at least as fast as using a StringBuffer. And if everything in the expression is a compile-time constant, then using + is almost certainly faster than StringBuffer, because all the work will be done at compile time.

"I'm not back." - Bill Harding, Twister

Kris Philippaerts

Greenhorn

Posts: 25

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

Originally posted by Ilja Preuss:
Can you show us the benchmark code?

Also, what JDK did you run this on? This might heavily affect performance differences.

I just took Krishna Srinivasan's code and cleaned it up a bit. I'm not sure what JDK I used at home. But I tried it again at work with JDK 1.4.2_03 (on a faster PC that at home). These are the results:

So, the -O option doesn't do much. The ratio of 5 times faster holds.

Grtz,
Kris

Sample.java

public class Sample {
private final static int ITERATION_COUNT = 100000;

public static void main(String[] args) {
/*
 * String version
 */
long startTimeString = System.currentTimeMillis();
 
for (int i=0; i<ITERATION_COUNT; i++) {
DateFormatString.getDate("10122003","mm/dd/yyyy");
}
 
long endTimeString = System.currentTimeMillis();
long totalTimeString = endTimeString - startTimeString;
double timePerIterationString = (double)totalTimeString / ITERATION_COUNT;

System.out.println("Total time: " + totalTimeString + " ms");
System.out.println("String version took avg. " + timePerIterationString + " ms / iteration");

/*
 * StringBuffer version
 */
long startTimeStringBuffer = System.currentTimeMillis();
 
for (int i=0; i<ITERATION_COUNT; i++) {
DateFormatStringBuffer.getDate("10122003","mm/dd/yyyy");
}
 
long endTimeStringBuffer = System.currentTimeMillis();
long totalTimeStringBuffer = endTimeStringBuffer - startTimeStringBuffer;
double timePerIterationStringBuffer = (double)totalTimeStringBuffer / ITERATION_COUNT;

System.out.println("Total time: " + totalTimeStringBuffer + " ms");
System.out.println("StringBuffer version took avg. " + timePerIterationStringBuffer + " ms / iteration");
}
}

DateFormatString.java

DateFormatStringBuffer.java

Ilja Preuss

author

Posts: 14112

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

Thanks for sharing the code!

One more tip: an important thing to do is to try wether swapping the order of execution, that is executing the StringBuffer version before the String version, makes a difference. It *could* have an impact because of incremental optimizations done by the Hotspot Engine.

Ilja Preuss

author

Posts: 14112

posted 21 years ago

Number of slices to send:

Optional 'thank-you' note:

Send

FYI, I just tried swapping the order, and it doesn't make a difference.

With a little knowledge, a cast iron skillet is non-stick and lasts a lifetime.