[Java] Speed comparison of string concatenation

Introduction

It has already been widely known from a long time ago (* around Java 1.5) that "string concatenation is not" + ", but using StringBuffer speeds up processing". Therefore, I still basically use StringBuffer and StringBuilder for string concatenation, but I suddenly wondered "How fast is the processing speed of the concat method of the String class?", So this time, these processing speeds I tried to compare.

testing environment

• PC
• CPU：Core-i5 8250U
• RAM：8GB
• JDK：Java-1.8.0_191

Code used for testing

• I have created a code that combines the letters "abc" 100,000 times.
• Initially, the code was combined 1 million times, but the number of combinations was reduced because the process was not completed.
• Compiling was Java 1.8 compliant.

StringTest.java

public class StringTest {
	public static void main(String[] args) {
		plus();
		concat();
		builder();
		buffer();
	}

	public static void plus() {

		long start = System.currentTimeMillis();
		String txt = "abc";

		for (int i=0; i<100000; i++) {
			txt += "abc";
		}

		long end = System.currentTimeMillis();
		System.out.println("+:" + (end - start) + "ms");
	}

	public static void concat() {

		long start = System.currentTimeMillis();
		String txt = "abc";

		for (int i=0; i<100000; i++) {
			txt = txt.concat("abc");
		}

		long end = System.currentTimeMillis();
		System.out.println("concat:" + (end - start) + "ms");
	}

	public static void builder() {

		long start = System.currentTimeMillis();
		StringBuilder sb = new StringBuilder("abc");

		for (int i=0; i<100000; i++) {
			sb.append("abc");
		}

		String txt = sb.toString();
		long end = System.currentTimeMillis();
		System.out.println("StringBuilder:" + (end - start) + "ms");
	}

	public static void buffer() {

		long start = System.currentTimeMillis();
		StringBuffer sb = new StringBuffer("abc");

		for (int i=0; i<100000; i++) {
			sb.append("abc");
		}

		String txt = sb.toString();
		long end = System.currentTimeMillis();
		System.out.println("StringBuffer:" + (end - start) + "ms");
	}
}

test results

Consideration of test results

Natural level story

• In "Join by +", the process is slow because "Every time you combine strings with" + ", a new string object is created and the reference is set in the variable (txt)".
• Not limited to Java, creating objects is costly ...
• String-type objects are immutable, so such defensive copying is done.
• StringBuilder and StringBuffer are overwhelmingly faster than "combine with +" because they just add a string to the string buffer (variable string) and no new objects are created.
• StringBuilder is thread-unsafe (* synchronization is not guaranteed) and StringBuffer is thread-safe (* synchronization is guaranteed), so StringBuffer is slightly slower (although it is an error level).

Why is String.concat () a bit faster than "join by +"?

String.concat()

• Looking at the source of String.concat (), it is the process of "combining two char type arrays and finally converting them to a String type object" as shown below.
• In other words, the object is created once in "Generation of the last String type object".

String.class excerpt

//Source obtained using the Eclipse Class Decompiler plugin.

public final class String implements Serializable, Comparable<String>, CharSequence {
   private final char[] value;

   public String concat(String arg0) {
      int arg1 = arg0.length();
      if(arg1 == 0) {
         return this;
      } else {
         int arg2 = this.value.length;
         char[] arg3 = Arrays.copyOf(this.value, arg2 + arg1);
         arg0.getChars(arg3, arg2);
         return new String(arg3, true);
      }
   }

   void getChars(char[] arg0, int arg1) {
      System.arraycopy(this.value, 0, arg0, arg1, this.value.length);
   }
}

Combine with +

• On the other hand, "Join with +" is described in Official Document. It seems that the process is "Concatenate strings with StringBuilder.append () and then convert to a String type object".
• In other words, the object is created twice in total, "Generate StringBuilder object" and "Create last String type object".
• According to this site, String.valueOf () is also called internally. There seems to be.

The Java language provides special support for string concatenation operators (+) and other object-to-string conversions. String concatenation is implemented using the StringBuilder (or StringBuffer) class and its append method.

Summary

• For string concatenation, you should actively use StringBuilder or StringBuffer as usual.
• If you need to be thread-safe, be sure to use StringBuffer.
• It seems better to use String.concat () instead of "+" even if the string concatenation is only once.
• Until now, I thought that the performance of "Join by +" and String.concat () would not change much, but I was surprised at the unexpected result.
• Even a slight difference in performance may slightly change the performance of the entire system with "Chiritsumo" ...