[Java] Comparaison de vitesse de combinaison de chaînes

introduction

Il était déjà largement connu depuis longtemps (* autour de Java 1.5) que "les jointures de chaîne ne sont pas" + ", mais l'utilisation de StringBuffer accélère le processus." Par conséquent, j'utilise toujours en gros StringBuffer et StringBuilder pour la concaténation de chaînes, mais je me suis soudainement demandé "Quelle est la vitesse de traitement de la méthode concat de la classe String?", Donc cette fois, ces vitesses de traitement J'ai essayé de comparer.

environnement de test

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

Code utilisé pour les tests

• J'ai créé un code qui combine les lettres «abc» 100 000 fois.
• Initialement, le code a été combiné 1 million de fois, mais le nombre de combinaisons a été réduit car le processus n'était pas terminé.
• Compilé selon Java 1.8.

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");
	}
}

résultats de test

Prise en compte des résultats des tests

Histoire de niveau naturel

• Dans "Join with +", le processus est lent car "Chaque fois que vous combinez des chaînes avec" + ", un nouvel objet string est créé et sa référence est définie dans la variable (txt)".
• Non limité à Java, la création d'objets est coûteuse ...
• Les objets de type chaîne sont immuables, donc cette copie défensive est effectuée.
• StringBuilder et StringBuffer sont extrêmement plus rapides que "Join with +" car ils ajoutent uniquement une chaîne au tampon de chaîne (chaîne variable) et ne créent pas de nouvel objet.
• StringBuilder est thread unsafe (* la synchronisation n'est pas garantie) et StringBuffer est thread safe (* la synchronisation est garantie), donc StringBuffer est légèrement plus lent (bien qu'il s'agisse d'un niveau d'erreur).

Pourquoi String.concat () est-il un peu plus rapide que "join by +"?

String.concat()

• En regardant la source de String.concat (), c'est le processus de "combinaison de deux tableaux de type char et finalement de les convertir en un objet de type String" comme indiqué ci-dessous.
• En d'autres termes, l'objet sera créé une fois dans "Génération du dernier objet de type String".

String.Extrait de cours

//Source obtenue à l'aide du plugin Eclipse Class Decompiler.

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);
   }
}

Combiner avec +

• D'autre part, "join by +" est décrit dans Official Document. Il semble que le processus soit "après avoir combiné des chaînes avec StringBuilder.append (), il est converti en un objet de type String".
• En d'autres termes, l'objet est créé deux fois au total, "Générer l'objet StringBuilder" et "Créer le dernier objet de type String".
• Selon ce site, String.valueOf () est également appelé en interne. Il semble y avoir.

Le langage Java fournit une prise en charge spéciale des opérateurs de concaténation de chaînes (+) et d'autres conversions objet-chaîne. La concaténation de chaînes est implémentée à l'aide de la classe StringBuilder (ou StringBuffer) et de sa méthode append.

Résumé

• Pour la combinaison de chaînes, vous devez utiliser activement StringBuilder ou StringBuffer comme d'habitude.
• Si vous devez être thread-safe, utilisez toujours StringBuffer.
• Il semble préférable d'utiliser String.concat () au lieu de "+" même si la chaîne n'est jointe qu'une seule fois.
• Jusqu'à présent, je pensais que les performances de "Join by +" et String.concat () ne changeraient pas grand-chose, mais j'ai été surpris du résultat inattendu.
• Même une légère différence de performances peut légèrement modifier les performances de l'ensemble du système avec "Chiritsumo" ...