Performans önemliyse Java'nın String.format () yöntemini kullanmalı mıyım?

Günlük çıkışı için her zaman Dizeler oluşturmalıyız vb. JDK sürümlerinde ne zaman kullanılacağını StringBuffer(birçok ek, iş parçacığı güvenli) ve StringBuilder(birçok ek , iş parçacığı için güvenli değil) öğrendik .

Kullanmayla ilgili tavsiye nedir String.format()? Verimli midir, yoksa performansın önemli olduğu tek gömlekler için birleştirme işlemine devam etmek zorunda mıyız?

örneğin çirkin eski tarz,

String s = "What do you get if you multiply " + varSix + " by " + varNine + "?";

düzenli yeni stil (muhtemelen daha yavaş olan String.format),

String s = String.format("What do you get if you multiply %d by %d?", varSix, varNine);

Not: Özel kullanım durumum, kodum boyunca yüzlerce 'tek satırlı' günlük dizesidir. Bir döngü içermezler, bu yüzden StringBuilderçok ağırdır. String.format()Özellikle ilgileniyorum .

Test etmek için küçük bir sınıf yazdım, bu ikisi daha iyi performansa sahip ve + formattan önce geliyor. 5 ile 6 arasında.

import java.io.*;
import java.util.Date;

public class StringTest{

    public static void main( String[] args ){
    int i = 0;
    long prev_time = System.currentTimeMillis();
    long time;

    for( i = 0; i< 100000; i++){
        String s = "Blah" + i + "Blah";
    }
    time = System.currentTimeMillis() - prev_time;

    System.out.println("Time after for loop " + time);

    prev_time = System.currentTimeMillis();
    for( i = 0; i<100000; i++){
        String s = String.format("Blah %d Blah", i);
    }
    time = System.currentTimeMillis() - prev_time;
    System.out.println("Time after for loop " + time);

    }
}

Yukarıdakileri farklı N için çalıştırmak, her ikisinin de doğrusal davrandığını, ancak String.format5-30 kat daha yavaş olduğunu gösterir.

Bunun nedeni, mevcut uygulamada String.formatönce girdiyi düzenli ifadelerle ayrıştırması ve daha sonra parametreleri doldurmasıdır. Öte yandan, artı ile birleştirme javac tarafından optimize edilir (JIT tarafından değil) ve StringBuilder.appenddoğrudan kullanılır.

Aldığım hhafez kodu ve bir katma bellek testi :

private static void test() {
    Runtime runtime = Runtime.getRuntime();
    long memory;
    ...
    memory = runtime.freeMemory();
    // for loop code
    memory = memory-runtime.freeMemory();

Bu ayrı ayrı her yaklaşım, '+' operatörü, String.format ve StringBuilder (toString () çağrılıyor) için çalıştırın, böylece kullanılan bellek diğer yaklaşımlardan etkilenmez. Dizeyi "Blah" + i + "Blah" + i + "Blah" + i + "Blah" olarak yaparak daha fazla birleştirme ekledim.

Sonuç aşağıdaki gibidir (her biri ortalama 5 çalışma):
Yaklaşma Süresi (ms) Tahsis edilen bellek (uzun)
'+' operatörü 747 320,504
String.format 16484 373,312
StringBuilder 769 57,344

String '+' ve StringBuilder'ın pratikte aynı özdeş olduklarını görebiliriz, ancak StringBuilder bellek kullanımında çok daha verimlidir. Bu, Çöp Toplayıcı '+' operatörünün neden olduğu birçok dize örneğini temizleyemeyecek kadar kısa bir sürede çok sayıda günlük çağrımız (veya dizelerle ilgili herhangi bir deyimimiz) olduğunda çok önemlidir.

Ve bir not, BTW, mesajı oluşturmadan önce günlük seviyesini kontrol etmeyi unutmayın .

Sonuç:

1. StringBuilder'ı kullanmaya devam edeceğim.
2. Çok fazla zamanım ya da çok az hayatım var.

Burada sunulan tüm kriterler bazı kusurlara sahiptir , bu nedenle sonuçlar güvenilir değildir.

Kıyaslama için kimsenin JMH kullanmadığına şaşırdım , bu yüzden yaptım.

Sonuçlar:

Benchmark             Mode  Cnt     Score     Error  Units
MyBenchmark.testOld  thrpt   20  9645.834 ± 238.165  ops/s  // using +
MyBenchmark.testNew  thrpt   20   429.898 ±  10.551  ops/s  // using String.format

Birimler saniyedeki işlemlerdir, daha iyi olur. Karşılaştırma kaynak kodu . OpenJDK IcedTea 2.5.4 Java Sanal Makinesi kullanıldı.

Yani, eski stil (+ kullanarak) çok daha hızlı.

Eski çirkin tarzınız JAVAC 1.6 tarafından otomatik olarak şu şekilde derlenir:

StringBuilder sb = new StringBuilder("What do you get if you multiply ");
sb.append(varSix);
sb.append(" by ");
sb.append(varNine);
sb.append("?");
String s =  sb.toString();

Yani bu ve bir StringBuilder kullanma arasında kesinlikle bir fark yoktur.

String.format çok daha ağırdır, çünkü yeni bir Formatter oluşturur, giriş formatı dizenizi ayrıştırır, bir StringBuilder oluşturur, her şeyi ona ekler ve toString () öğesini çağırır.

Java'nın String.format şu şekilde çalışır:

1. biçim dizesini ayrıştırır ve biçim parçaları listesinde patlar
2. yeni bir diziye kopyalayarak temelde gerektiği gibi kendini yeniden boyutlandıran bir dizi olan StringBuilder'a dönüştürerek biçim yığınlarını yineler. bu gereklidir, çünkü henüz son String'i ne kadar tahsis edeceğimizi bilmiyoruz
3. StringBuilder.toString () dahili arabelleğini yeni bir String'e kopyalar

bu veriler için son hedef bir akışsa (örn. bir web sayfası oluşturma veya bir dosyaya yazma), biçim yığınlarını doğrudan akışınıza monte edebilirsiniz:

new PrintStream(outputStream, autoFlush, encoding).format("hello {0}", "world");

Optimize edicinin biçim dizesi işlemeyi optimize edeceğini tahmin ediyorum. Öyleyse, String.format'ınızı bir StringBuilder'a manuel olarak açmak için eşdeğer amortisman performansına sahip olursunuz.

Yukarıdaki ilk cevabı genişletmek / düzeltmek, String.format'ın aslında yardımcı olacağı bir çeviri değildir.
String.format'ın yardımcı olacağı şey, yerelleştirme (l10n) farklılıklarının olduğu bir tarih / saat (veya sayısal biçim, vb.) Yazdırırken (yani, bazı ülkeler 04Feb2009 yazdıracak, diğerleri ise Feb042009 yazdıracaktır).
Çeviri ile, ResourceBundle ve MessageFormat'ı kullanarak doğru dil için doğru paketi kullanabilmeniz için, herhangi bir haricilaştırılabilir dizeyi (hata iletileri ve ne gibi) bir özellik paketine taşımaktan bahsediyorsunuz.

Yukarıdakilere baktığımda, performans açısından, String.format ve düz birleştirmenin tercih ettiğiniz şeye indiğini söyleyebilirim. Birleştirme üzerinden .format çağrılarına bakmayı tercih ediyorsanız, elbette bununla devam edin.
Sonuçta, kod yazıldığından çok daha fazla okunur.

Örneğinizde, performans probalby çok farklı değildir, ancak dikkate alınması gereken başka konular da vardır: yani bellek parçalanması. Birleştirme işlemi bile geçici olsa bile yeni bir dize oluşturuyor (GC'ye geçmek zaman alıyor ve daha fazla iş). String.format () sadece daha okunabilir ve daha az parçalanma içerir.

Ayrıca, belirli bir biçimi çok kullanıyorsanız, Formatter () sınıfını doğrudan kullanabileceğinizi unutmayın (tüm String.format (), bir kullanımlı Formatter örneğini başlatır).

Ayrıca, bilmeniz gereken başka bir şey: substring () kullanmaya dikkat edin. Örneğin:

String getSmallString() {
  String largeString = // load from file; say 2M in size
  return largeString.substring(100, 300);
}

Bu büyük dize hala bellekte çünkü Java alt dizeleri böyle çalışıyor. Daha iyi bir sürüm:

  return new String(largeString.substring(100, 300));

veya

  return String.format("%s", largeString.substring(100, 300));

Aynı anda başka şeyler yapıyorsanız ikinci form muhtemelen daha kullanışlıdır.

Genellikle String.Format'ı kullanmalısınız çünkü nispeten hızlıdır ve küreselleşmeyi destekler (aslında kullanıcı tarafından okunan bir şey yazmaya çalıştığınızı varsayarsak). Ayrıca, bir dizeyi ifade başına 3 veya daha fazlaya çevirmeye çalışıyorsanız (özellikle büyük ölçüde farklı gramer yapılarına sahip diller için) globalleşmeyi kolaylaştırır.

Eğer hiçbir şeyi tercüme etmeyi planlamıyorsanız, ya Java'nın + operatörlerinin içine dönüştürülmesine güvenin StringBuilder. Veya Java'yı StringBuilderaçıkça kullanın .

Yalnızca Günlükleme açısından başka bir perspektif.

Bu konuda oturum açma ile ilgili çok fazla tartışma görüyorum, bu yüzden cevabımı deneyimime eklemeyi düşündüm. Birisi faydalı bulabilir.

Sanırım biçimlendiriciyi kullanarak günlüğe kaydetme motivasyonu dize birleştirme kaçınmak geliyor. Temel olarak, günlüğe kaydetmeyecekseniz dize concat yükü istemezsiniz.

Oturum açmak istemediğiniz sürece gerçekten birleştirme / biçimlendirme yapmanız gerekmez. Diyelim ki böyle bir yöntem tanımlarsam

public void logDebug(String... args, Throwable t) {
    if(debugOn) {
       // call concat methods for all args
       //log the final debug message
    }
}

Bu yaklaşımda cancat / formatter gerçekten çağrılmazsa bir hata ayıklama mesajı ve debugOn = false

Yine de burada biçimlendirici yerine StringBuilder kullanmak daha iyi olacaktır. Ana motivasyon bunlardan kaçınmaktır.

Aynı zamanda her günlük ifadesi için "if" bloğu eklemeyi sevmiyorum

• Okunabilirliği etkiler
• Birim testlerimin kapsamını azaltır - bu, her hattın test edildiğinden emin olmak istediğinizde kafa karıştırıcıdır.

Bu nedenle, yukarıdaki gibi yöntemlerle bir günlük yardımcı programı sınıfı oluşturmayı ve performans isabetini ve bununla ilgili diğer sorunları düşünmeden her yerde kullanmayı tercih ederim.

Hhafez'in testini StringBuilder'ı içerecek şekilde değiştirdim. StringBuilder, XP'de jdk 1.6.0_10 istemcisini kullanarak String.format'tan 33 kat daha hızlıdır. -Server anahtarını kullanmak faktörü 20'ye düşürür.

public class StringTest {

   public static void main( String[] args ) {
      test();
      test();
   }

   private static void test() {
      int i = 0;
      long prev_time = System.currentTimeMillis();
      long time;

      for ( i = 0; i < 1000000; i++ ) {
         String s = "Blah" + i + "Blah";
      }
      time = System.currentTimeMillis() - prev_time;

      System.out.println("Time after for loop " + time);

      prev_time = System.currentTimeMillis();
      for ( i = 0; i < 1000000; i++ ) {
         String s = String.format("Blah %d Blah", i);
      }
      time = System.currentTimeMillis() - prev_time;
      System.out.println("Time after for loop " + time);

      prev_time = System.currentTimeMillis();
      for ( i = 0; i < 1000000; i++ ) {
         new StringBuilder("Blah").append(i).append("Blah");
      }
      time = System.currentTimeMillis() - prev_time;
      System.out.println("Time after for loop " + time);
   }
}

Bu kulağa sert gelse de, mutlak sayılar oldukça düşük olduğu için sadece nadir durumlarda alakalı olduğunu düşünüyorum: 1 milyon basit String için 4 s.format aramaları tamam - kayıt için kullandığım sürece sevmek.

Güncelleme: Yorumlarda sjbotha tarafından belirtildiği gibi, bir final eksik olduğu için StringBuilder testi geçersiz .toString().

Doğru hızlandırıcı faktör String.format(.)için StringBuilderbenim makinede (16 23 olan -serveranahtarı).

İşte hhafez girdisinin değiştirilmiş versiyonu. Bir dize oluşturucu seçeneği içerir.

public class BLA
{
public static final String BLAH = "Blah ";
public static final String BLAH2 = " Blah";
public static final String BLAH3 = "Blah %d Blah";


public static void main(String[] args) {
    int i = 0;
    long prev_time = System.currentTimeMillis();
    long time;
    int numLoops = 1000000;

    for( i = 0; i< numLoops; i++){
        String s = BLAH + i + BLAH2;
    }
    time = System.currentTimeMillis() - prev_time;

    System.out.println("Time after for loop " + time);

    prev_time = System.currentTimeMillis();
    for( i = 0; i<numLoops; i++){
        String s = String.format(BLAH3, i);
    }
    time = System.currentTimeMillis() - prev_time;
    System.out.println("Time after for loop " + time);

    prev_time = System.currentTimeMillis();
    for( i = 0; i<numLoops; i++){
        StringBuilder sb = new StringBuilder();
        sb.append(BLAH);
        sb.append(i);
        sb.append(BLAH2);
        String s = sb.toString();
    }
    time = System.currentTimeMillis() - prev_time;
    System.out.println("Time after for loop " + time);

}

}

Döngü 391 için zaman sonra Döngü 4163 için zaman sonra Döngü 227 için zaman sonra

Bunun cevabı, belirli Java derleyicinizin oluşturduğu bayt kodunu nasıl optimize ettiğine bağlıdır. Dizeler değişmezdir ve teorik olarak her "+" işlemi yeni bir tane oluşturabilir. Ancak, derleyiciniz uzun dizeler oluşturmak için ara adımları neredeyse kesinlikle optimize eder. Yukarıdaki her iki kod satırının da aynı bayt kodunu oluşturması tamamen mümkündür.

Bilmenin tek gerçek yolu, kodu mevcut ortamınızda yinelemeli olarak test etmektir. Dizeleri yinelemeli olarak her iki şekilde birleştiren bir QD uygulaması yazın ve birbirlerine karşı zaman aşımlarını görün.

"hello".concat( "world!" )Birleştirmede az sayıda dize kullanmayı düşünün . Performans için diğer yaklaşımlardan daha iyi olabilir.

3'ten fazla dizeniz varsa, kullandığınız derleyiciye bağlı olarak StringBuilder veya yalnızca String kullanmayı düşünün.