[JAVA] Ist das String # -Format (String, Object ...) wirklich langsam?

Einführung

• Zusammenfassend ist es sicherlich langsamer als die Verkettung von Zeichenfolgen
• Es ist jedoch häufig nicht angebracht, die Formatzeichenfolge durch eine Zeichenfolgenverkettung zu ersetzen. Besonders wenn es viele Parameter gibt oder wenn es notwendig ist, die Parameter in Zeichenketten umzuwandeln.
• Zum Zwecke "Platzhalter in Zeichenfolgen ersetzen" sollte der Vergleich zunächst das Format __java.text.MessageFormat # (Zeichenfolge, Objekt ...) __ und __StringBuilder # append (...) lauten. Keine Methodenkette von __
• Vergleichen wir also die Ausführungsgeschwindigkeiten des __String # -Formats (String, Object ...) __ und des __MessageFormat # -Formats (String, Object ...) __. (Benchmark1)
• Außerdem wird ein Vergleich durchgeführt, bei dem die ersetzte Zeichenfolge beibehalten wird. Vergleich von __StringBuilder + String # -Format (String, Objekt ...) __ und __java.util.Formatter # -Format (String, Objekt ...) __ (Benchmark2)

Umgebung

    |Ausführung|
---+----------+
OS | macOS 10.14.6
Java | 1.8.0.202

Benchmark

• Ersetzen Sie 2 Zeichenfolgen und 5 Zahlenwerte 1 Million Mal, um den Durchschnittswert zu berechnen

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Formatter;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

class FormatPerformance {
	/**
	 *Anzahl der Schleifen(1 Million Mal)
	 */
	private final int LOOP = 1000 * 1000;
	private static final ThreadLocalRandom random = ThreadLocalRandom.current();

	public static void main(String[] args) {
		FormatPerformance fp = new FormatPerformance();

		System.out.println("===== benchmark1 =====");
		fp.benchmark1();
		System.out.println("");
		System.out.println("===== benchmark2 =====");
		fp.benchmark2();
	}

	/**
	 *Gibt eine zufällige Zeichenfolge zurück
	 * 
	 * @Rückgabe einer zufälligen Alphabetzeichenfolge
	 */
	private String randomString() {
		final int size = random.nextInt(16) + 1;
		StringBuilder sb = new StringBuilder(size);
		for (int i = 0; i < size; i++) {
			sb.append((char)('a' + random.nextInt(26)));
		}
		return sb.toString();
	}

	/**
	 *Formatkonvertierungsbank<br>
	 * {@link String#format(String, Object...)} vs {@link MessageFormat#format(String, Object...)}
	 */
	private void benchmark1() {
		final String[][] expects = { { "groß!%s ist%Freunde, die gut in s sind!", "IP Adresse%d.%d.%d.%d/%d" },
				{ "groß!{0}Ist{1}Ich bin gut in Freunden!", "IP Adresse{0}.{1}.{2}.{3}/{4}" }, };

		long totalByConcat = 0;
		long totalByString = 0;
		long totalByMessage = 0;
		for (int i = 0; i < LOOP; i++) {
			String paramStr1 = randomString();
			String paramStr2 = randomString();
			int paramInt1 = random.nextInt(255);
			int paramInt2 = random.nextInt(255);
			int paramInt3 = random.nextInt(255);
			int paramInt4 = random.nextInt(255);
			int paramInt5 = random.nextInt(32);
			List<String> list = new ArrayList<>();

			//String-Verkettung
			{
				long begin = System.nanoTime();
				String sugoi = "groß!" + paramStr1 + "Ist" + paramStr2 + "Ich bin gut in Freunden!";
				String ipAddress = "IP Adresse" + Integer.toString(paramInt1) + "." + Integer.toString(paramInt2) + "."
						+ Integer.toString(paramInt3) + "." + Integer.toString(paramInt4) + "/"
						+ Integer.toString(paramInt5);
				totalByConcat += System.nanoTime() - begin;
				list.add(sugoi);
				list.add(ipAddress);
			}

			// String#format(String, Object...)
			{
				long begin = System.nanoTime();
				String sugoi = String.format(expects[0][0], paramStr1, paramStr2);
				String ipAddress = String.format(expects[0][1], paramInt1, paramInt2, paramInt3, paramInt4, paramInt5);
				totalByString += System.nanoTime() - begin;
				list.add(sugoi);
				list.add(ipAddress);
			}

			// MessageFormat#format(String, Object...)
			{
				long begin = System.nanoTime();
				String sugoi = MessageFormat.format(expects[1][0], paramStr1, paramStr2);
				String ipAddress = MessageFormat.format(expects[1][1], paramInt1, paramInt2, paramInt3, paramInt4, paramInt5);
				totalByMessage += System.nanoTime() - begin;
				list.add(sugoi);
				list.add(ipAddress);
			}
		}
		System.out.println(String.format("String concatenation average = %d[ns]", totalByConcat / LOOP));
		System.out.println(String.format("String#format(String, Object...) average = %d[ns]", totalByString / LOOP));
		System.out.println(String.format("MessageFormat#format(String, Object...) average = %d[ns]", totalByMessage / LOOP));
	}

	/**
	 *Eine Bank, auf der formatierte Zeichenfolgen gespeichert sind<br>
	 * {@link String#format(String, Object...)} vs {@link Formatter#format(String, Object...)}
	 */
	private void benchmark2() {
		final String[] expects = { "groß!%s ist%Freunde, die gut in s sind!", "IP Adresse%d.%d.%d.%d/%d" };

		long totalByString = 0;
		long totalByFormatter = 0;
		for (int i = 0; i < LOOP; i++) {
			String paramStr1 = randomString();
			String paramStr2 = randomString();
			int paramInt1 = random.nextInt(255);
			int paramInt2 = random.nextInt(255);
			int paramInt3 = random.nextInt(255);
			int paramInt4 = random.nextInt(255);
			int paramInt5 = random.nextInt(32);

			// StringBuilder + String#format
			{
				long begin = System.nanoTime();
				StringBuilder sb = new StringBuilder();
				sb.append(String.format(expects[0], paramStr1, paramStr2));
				sb.append(String.format(expects[1], paramInt1, paramInt2, paramInt3, paramInt4, paramInt5));
				totalByString += System.nanoTime() - begin;
			}

			// Formatter#format
			{
				long begin = System.nanoTime();
				try (Formatter formatter = new Formatter();) {
					formatter.format(expects[0], paramStr1, paramStr2);
					formatter.format(expects[1], paramInt1, paramInt2, paramInt3, paramInt4, paramInt5);
				}
				totalByFormatter += System.nanoTime() - begin;
			}
		}

		System.out.println(String.format("String#format(String, Object...) average = %d[ns]", totalByString / LOOP));
		System.out.println(String.format("Formatter#format(String, Object...) average = %d[ns]", totalByFormatter / LOOP));
	}
}

Ausgabe (Durchschnitt pro Million Mal)

===== benchmark1 =====
String concatenation average = 269[ns]
String#format(String, Object...) average = 2383[ns]
MessageFormat#format(String, Object...) average = 4572[ns]

===== benchmark2 =====
String#format(String, Object...) average = 2302[ns]
Formatter#format(String, Object...) average = 2101[ns]

Ergebnis

benchmark1 --String-Join ist fast zehnmal schneller als das __String # -Format (String, Object ...) __

• Das __String # -Format (String, Object ...) __ ist jedoch etwa 40 bis 50% schneller als das __MessageFormat # -Format (String, Object ...) __.

• String # format scheint langsam zu sein, da es intern reguläre Ausdrücke verwendet, aber die Zeichenfolge in StringBuilder enthält. Auf der anderen Seite verwendet MessageFormat # format StringBuffer. Darüber hinaus ist es schwer, da es mehr als nur einfache Ersetzungen wie das Hinzufügen von Kommas durchführen kann.

benchmark2

• Wenn Sie die Zeichenfolge nach dem Ersetzen der Formatzeichenfolge akkumulieren möchten, gibt es java.util.Formatter, was etwas schneller ist als das Kombinieren des Formats StringBuilder und __String # (String, Object ...) __.

• Dies liegt vermutlich daran, dass das __String # -Format (String, Object ...) __ intern Formatter für jeden Aufruf generiert.