Devo usar o String.format () do Java se o desempenho for importante?

Temos que criar Strings o tempo todo para a saída do log e assim por diante. Nas versões do JDK, aprendemos quando usarStringBuffer (muitos anexos, segurança de thread) e StringBuilder(muitos anexos, não-thread-safe).

Qual é o conselho sobre o uso String.format() ? É eficiente ou somos forçados a manter a concatenação para one-liners onde o desempenho é importante?

por exemplo, feio estilo antigo,

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

vs. novo estilo organizado (String.format, que é possivelmente mais lento),

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

Nota: meu caso de uso específico são as centenas de seqüências de log 'one-liner' em todo o meu código. Eles não envolvem um loop, por isso StringBuilderé muito pesado. Estou interessado String.format()especificamente.

Eu escrevi uma turma pequena para testar qual o melhor desempenho dos dois e + vem à frente do formato. por um fator de 5 a 6. Tente você mesmo

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

    }
}

A execução do acima para N diferente mostra que ambos se comportam linearmente, mas String.formatsão de 5 a 30 vezes mais lentos.

O motivo é que, na implementação atual, String.formatprimeiro analisa a entrada com expressões regulares e depois preenche os parâmetros. A concatenação com plus, por outro lado, é otimizada pelo javac (não pelo JIT) e usa StringBuilder.appenddiretamente.

Tomei hhafez código e acrescentou um teste de memória :

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

Eu executo isso separadamente para cada abordagem, o operador '+', String.format e StringBuilder (chamando toString ()), para que a memória usada não seja afetada por outras abordagens. Adicionei mais concatenações, criando a string como "Blah" + i + "Blah" + i + "Blah" + i + "Blah".

O resultado é o seguinte (média de 5 execuções cada):
Tempo de Aproximação (ms) Memória alocada (longa)
operador '+' 747 320,504
String.format 16484 373,312
StringBuilder 769 57,344

Podemos ver que String '+' e StringBuilder são praticamente idênticos em termos de tempo, mas StringBuilder é muito mais eficiente no uso de memória. Isso é muito importante quando temos muitas chamadas de log (ou quaisquer outras instruções que envolvem cadeias) em um intervalo de tempo suficientemente curto para que o Garbage Collector não consiga limpar as muitas instâncias de cadeias resultantes do operador '+'.

E uma observação, BTW, não se esqueça de verificar o nível de log antes de construir a mensagem.

Conclusões:

1. Vou continuar usando o StringBuilder.
2. Eu tenho muito tempo ou muito pouca vida.

Todos os benchmarks apresentados aqui apresentam algumas falhas , portanto, os resultados não são confiáveis.

Fiquei surpreso que ninguém usasse o JMH para fazer benchmarking, então usei .

Resultados:

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

Unidades são operações por segundo, quanto mais, melhor. Código fonte de referência . Foi utilizada a Java Virtual Machine do OpenJDK IcedTea 2.5.4.

Portanto, o estilo antigo (usando +) é muito mais rápido.

Seu velho estilo feio é compilado automaticamente pelo JAVAC 1.6 como:

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

Portanto, não há absolutamente nenhuma diferença entre isso e o uso de um StringBuilder.

String.format é muito mais pesado, pois cria um novo Formatador, analisa sua string de formato de entrada, cria um StringBuilder, acrescenta tudo a ele e chama toString ().

O String.format do Java funciona assim:

1. analisa a cadeia de formato, explodindo em uma lista de blocos de formato
2. itera os pedaços de formato, renderizando em um StringBuilder, que é basicamente uma matriz que se redimensiona conforme necessário, copiando para uma nova matriz. isso é necessário porque ainda não sabemos o tamanho da alocação da String final
3. StringBuilder.toString () copia seu buffer interno em uma nova String

se o destino final desses dados for um fluxo (por exemplo, renderizar uma página da Web ou gravar em um arquivo), você poderá montar os pedaços de formato diretamente no seu fluxo:

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

Especulo que o otimizador otimizará o processamento da string de formato. Nesse caso, você terá um desempenho amortizado equivalente para desenrolar manualmente seu String.format em um StringBuilder.

Para expandir / corrigir a primeira resposta acima, não é a tradução com a qual String.format ajudaria.
O que o String.format ajudará é quando você estiver imprimindo uma data / hora (ou um formato numérico, etc.), onde existem diferenças de localização (l10n) (ou seja, alguns países imprimirão 04Feb2009 e outros imprimirão Feb042009).
Com a tradução, você está apenas falando sobre mover quaisquer strings externalizáveis ​​(como mensagens de erro e outras coisas) para um pacote configurável de propriedades, para que você possa usar o pacote correto para o idioma certo, usando ResourceBundle e MessageFormat.

Observando tudo o que foi dito acima, eu diria que a concatenação String.format versus planilha se resume ao que você preferir. Se você preferir olhar as chamadas para .format do que a concatenação, faça isso de qualquer maneira.
Afinal, o código é lido muito mais do que está escrito.

No seu exemplo, o desempenho provavelmente não é muito diferente, mas há outros problemas a serem considerados: a fragmentação da memória. Até a operação concatenada está criando uma nova string, mesmo que seja temporária (leva tempo para GC e é mais trabalho). String.format () é apenas mais legível e envolve menos fragmentação.

Além disso, se você estiver usando muito um determinado formato, não esqueça que pode usar a classe Formatter () diretamente (tudo o que String.format () faz é instanciar uma instância do Formatter de uso único).

Além disso, você deve estar ciente de outra coisa: tenha cuidado ao usar substring (). Por exemplo:

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

Essa cadeia grande ainda está na memória, porque é assim que as substrings Java funcionam. Uma versão melhor é:

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

ou

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

A segunda forma é provavelmente mais útil se você estiver fazendo outras coisas ao mesmo tempo.

Geralmente você deve usar String.Format porque é relativamente rápido e suporta a globalização (supondo que você esteja realmente tentando escrever algo que é lido pelo usuário). Também facilita a globalização se você estiver tentando traduzir uma string em vez de 3 ou mais por instrução (especialmente para idiomas que possuem estruturas gramaticais drasticamente diferentes).

Agora, se você nunca planeja traduzir nada, confie na conversão incorporada de Java dos operadores + em StringBuilder. Ou use StringBuilderexplicitamente o Java .

Outra perspectiva apenas do ponto de vista de registro.

Eu vejo muitas discussões relacionadas ao logon neste tópico, então pensei em adicionar minha experiência em resposta. Pode ser que alguém ache útil.

Eu acho que a motivação do log usando o formatador vem de evitar a concatenação de strings. Basicamente, você não deseja ter uma sobrecarga de concat de strings se não quiser registrá-lo.

Você realmente não precisa concat / formatar, a menos que queira fazer logon. Digamos que se eu definir um método como este

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

Nesta abordagem, o cancelador / formatador não é realmente chamado se for uma mensagem de depuração e debugOn = false

Embora ainda seja melhor usar o StringBuilder em vez do formatador aqui. A principal motivação é evitar nada disso.

Ao mesmo tempo, não gosto de adicionar o bloco "if" para cada instrução de log desde

• Afeta a legibilidade
• Reduz a cobertura nos meus testes de unidade - isso é confuso quando você deseja garantir que todas as linhas sejam testadas.

Portanto, prefiro criar uma classe de utilitário de log com métodos como acima e usá-la em qualquer lugar sem se preocupar com o desempenho atingido e quaisquer outros problemas relacionados a ela.

Acabei de modificar o teste de Hhafez para incluir o StringBuilder. O StringBuilder é 33 vezes mais rápido que o String.format usando o cliente jdk 1.6.0_10 no XP. O uso da opção -server reduz o fator para 20.

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

Embora isso possa parecer drástico, considero relevante apenas em casos raros, porque os números absolutos são bastante baixos: 4 s para 1 milhão de chamadas String.format simples é uma espécie de ok - desde que eu os use para registrar ou gostar.

Atualização: Como apontado por sjbotha nos comentários, o teste StringBuilder é inválido, pois está faltando uma final .toString().

O fator de aceleração correto de String.format(.)a StringBuilderé 23 na minha máquina (16 com a -serverchave).

Aqui está a versão modificada da entrada hhafez. Inclui uma opção do construtor de cadeias.

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

}

}

Time after for loop 391 Time after for loop 4163 Time after for loop 227

A resposta para isso depende muito de como o seu compilador Java específico otimiza o bytecode gerado. Strings são imutáveis ​​e, teoricamente, cada operação "+" pode criar uma nova. Mas seu compilador quase certamente otimiza as etapas intermediárias na construção de seqüências longas. É perfeitamente possível que ambas as linhas de código acima gerem exatamente o mesmo bytecode.

A única maneira real de saber é testar o código iterativamente no seu ambiente atual. Escreva um aplicativo QD que concatene seqüências de caracteres nos dois sentidos de forma iterativa e veja como elas se esgotam.

Considere usar "hello".concat( "world!" )para um pequeno número de seqüências de caracteres na concatenação. Poderia ser ainda melhor para desempenho do que outras abordagens.

Se você tiver mais de três seqüências, considere usar StringBuilder ou apenas String, dependendo do compilador que você usa.