Лучше ли использовать String.формат конкатенации строк в Java?

есть ли заметная разница между использованием String.Format и конкатенация строк в Java?

Я предпочитаю использовать String.format но иногда будет скользить и использовать concat. Интересно, одно лучше другого?

как я это вижу,String.Format дает вам больше возможностей в "форматировании" строки; и конкатенация означает, что вам не нужно беспокоиться о случайном вводе дополнительного %s или его отсутствии.

String.format тоже укорачиваться.

какой из них более читаемый, зависит от того, как работает ваша голова.

206
concatenation java string string.format

12 ответов

Я бы предположил, что лучше использоватьString.format(). Главная причина в том, что String.format() можно легче локализовать с помощью текста, загруженного из файлов ресурсов, тогда как конкатенация не может быть локализована без создания нового исполняемого файла с другим кодом для каждого языка.

если вы планируете, что ваше приложение будет локализовано, вы также должны привыкнуть указывать позиции аргументов для своих токенов формата:

"Hello %1$s the time is %2$t"

Это можно после этого локализовать и замените маркеры имени и времени, не требуя перекомпиляции исполняемого файла для учета различного порядка. С позициями аргументов вы также можете повторно использовать один и тот же аргумент, не передавая его в функцию дважды:

String.format("Hello %1$s, your name is %1$s and the time is %2$t", name, time)
196

о работе:

public static void main(String[] args) throws Exception {      
  long start = System.currentTimeMillis();
  for(int i = 0; i < 1000000; i++){
    String s = "Hi " + i + "; Hi to you " + i*2;
  }
  long end = System.currentTimeMillis();
  System.out.println("Concatenation = " + ((end - start)) + " millisecond") ;

  start = System.currentTimeMillis();
  for(int i = 0; i < 1000000; i++){
    String s = String.format("Hi %s; Hi to you %s",i, + i*2);
  }
  end = System.currentTimeMillis();
  System.out.println("Format = " + ((end - start)) + " millisecond");
}

результаты выглядят следующим образом:

  • конкатенация = 265 МС
  • Format = 4141 миллисекунда

таким образом, конкатенация намного быстрее, чем строка.формат.

125

поскольку есть обсуждение производительности, я решил добавить в сравнение, которое включало StringBuilder. Это на самом деле быстрее, чем конкат и, естественно, строка.параметр форматирования.

чтобы сделать это своего рода сравнение яблок с яблоками, я создаю экземпляр нового StringBuilder в цикле, а не снаружи (это на самом деле быстрее, чем делать только один экземпляр, скорее всего, из-за накладных расходов на перераспределение пространства для добавления цикла в конце одного строитель.)

    String formatString = "Hi %s; Hi to you %s";

    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s = String.format(formatString, i, +i * 2);
    }

    long end = System.currentTimeMillis();
    log.info("Format = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        String s = "Hi " + i + "; Hi to you " + i * 2;
    }

    end = System.currentTimeMillis();

    log.info("Concatenation = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        StringBuilder bldString = new StringBuilder("Hi ");
        bldString.append(i).append("; Hi to you ").append(i * 2);
    }

    end = System.currentTimeMillis();

    log.info("String Builder = " + ((end - start)) + " millisecond");
  • 2012-01-11 16: 30: 46,058 INFO [TestMain] - Format = 1416 миллисекунда
  • 2012-01-11 16: 30: 46,190 INFO [TestMain] - конкатенация = 134 миллисекунда
  • 2012-01-11 16: 30: 46,313 INFO [TestMain] - строковый конструктор = 117 миллисекунд
35

одна проблема с .format Это то, что вы теряете статическую безопасность типа. У вас может быть слишком мало аргументов для вашего формата, и вы можете иметь неправильные типы для спецификаторов формата - оба приводят к IllegalFormatException во время, так что вы можете в конечном итоге с кодом ведения журнала, который нарушает производство.

В отличие от аргументов + могут быть проверены компилятором.

28

какой из них более удобочитаем, зависит от того, как работает ваша голова.

вы получили свой ответ прямо здесь.

это вопрос личного вкуса.

конкатенация строк немного быстрее, я полагаю, но это должно быть незначительно.

14

вот тест с несколькими размерами выборки в миллисекундах. 

public class Time {

public static String sysFile = "/sys/class/camera/rear/rear_flash";
public static String cmdString = "echo %s > " + sysFile;

public static void main(String[] args) {

  int i = 1;
  for(int run=1; run <= 12; run++){
      for(int test =1; test <= 2 ; test++){
        System.out.println(
                String.format("\nTEST: %s, RUN: %s, Iterations: %s",run,test,i));
        test(run, i);
      }
      System.out.println("\n____________________________");
      i = i*3;
  }
}

public static void test(int run, int iterations){

      long start = System.nanoTime();
      for( int i=0;i<iterations; i++){
          String s = "echo " + i + " > "+ sysFile;
      }
      long t = System.nanoTime() - start;   
      String r = String.format("  %-13s =%10d %s", "Concatenation",t,"nanosecond");
      System.out.println(r) ;


     start = System.nanoTime();       
     for( int i=0;i<iterations; i++){
         String s =  String.format(cmdString, i);
     }
     t = System.nanoTime() - start; 
     r = String.format("  %-13s =%10d %s", "Format",t,"nanosecond");
     System.out.println(r);

      start = System.nanoTime();          
      for( int i=0;i<iterations; i++){
          StringBuilder b = new StringBuilder("echo ");
          b.append(i).append(" > ").append(sysFile);
          String s = b.toString();
      }
     t = System.nanoTime() - start; 
     r = String.format("  %-13s =%10d %s", "StringBuilder",t,"nanosecond");
     System.out.println(r);
}

}

TEST: 1, RUN: 1, Iterations: 1
  Concatenation =     14911 nanosecond
  Format        =     45026 nanosecond
  StringBuilder =      3509 nanosecond

TEST: 1, RUN: 2, Iterations: 1
  Concatenation =      3509 nanosecond
  Format        =     38594 nanosecond
  StringBuilder =      3509 nanosecond

____________________________

TEST: 2, RUN: 1, Iterations: 3
  Concatenation =      8479 nanosecond
  Format        =     94438 nanosecond
  StringBuilder =      5263 nanosecond

TEST: 2, RUN: 2, Iterations: 3
  Concatenation =      4970 nanosecond
  Format        =     92976 nanosecond
  StringBuilder =      5848 nanosecond

____________________________

TEST: 3, RUN: 1, Iterations: 9
  Concatenation =     11403 nanosecond
  Format        =    287115 nanosecond
  StringBuilder =     14326 nanosecond

TEST: 3, RUN: 2, Iterations: 9
  Concatenation =     12280 nanosecond
  Format        =    209051 nanosecond
  StringBuilder =     11818 nanosecond

____________________________

TEST: 5, RUN: 1, Iterations: 81
  Concatenation =     54383 nanosecond
  Format        =   1503113 nanosecond
  StringBuilder =     40056 nanosecond

TEST: 5, RUN: 2, Iterations: 81
  Concatenation =     44149 nanosecond
  Format        =   1264241 nanosecond
  StringBuilder =     34208 nanosecond

____________________________

TEST: 6, RUN: 1, Iterations: 243
  Concatenation =     76018 nanosecond
  Format        =   3210891 nanosecond
  StringBuilder =     76603 nanosecond

TEST: 6, RUN: 2, Iterations: 243
  Concatenation =     91222 nanosecond
  Format        =   2716773 nanosecond
  StringBuilder =     73972 nanosecond

____________________________

TEST: 8, RUN: 1, Iterations: 2187
  Concatenation =    527450 nanosecond
  Format        =  10291108 nanosecond
  StringBuilder =    885027 nanosecond

TEST: 8, RUN: 2, Iterations: 2187
  Concatenation =    526865 nanosecond
  Format        =   6294307 nanosecond
  StringBuilder =    591773 nanosecond

____________________________

TEST: 10, RUN: 1, Iterations: 19683
  Concatenation =   4592961 nanosecond
  Format        =  60114307 nanosecond
  StringBuilder =   2129387 nanosecond

TEST: 10, RUN: 2, Iterations: 19683
  Concatenation =   1850166 nanosecond
  Format        =  35940524 nanosecond
  StringBuilder =   1885544 nanosecond

  ____________________________

TEST: 12, RUN: 1, Iterations: 177147
  Concatenation =  26847286 nanosecond
  Format        = 126332877 nanosecond
  StringBuilder =  17578914 nanosecond

TEST: 12, RUN: 2, Iterations: 177147
  Concatenation =  24405056 nanosecond
  Format        = 129707207 nanosecond
  StringBuilder =  12253840 nanosecond
13

вот тот же Тест, что и выше с модификацией вызова toString () метод StringBuilder. Результаты ниже показывают, что подход StringBuilder немного медленнее, чем конкатенация строк с помощью + оператора.

файл: StringTest.java

class StringTest {

  public static void main(String[] args) {

    String formatString = "Hi %s; Hi to you %s";

    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s = String.format(formatString, i, +i * 2);
    }

    long end = System.currentTimeMillis();
    System.out.println("Format = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        String s = "Hi " + i + "; Hi to you " + i * 2;
    }

    end = System.currentTimeMillis();

    System.out.println("Concatenation = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        StringBuilder bldString = new StringBuilder("Hi ");
        bldString.append(i).append("Hi to you ").append(i * 2).toString();
    }

    end = System.currentTimeMillis();

    System.out.println("String Builder = " + ((end - start)) + " millisecond");

  }
}

команды оболочки: (скомпилировать и запустить StringTest 5 раз)

> javac StringTest.java
> sh -c "for i in $(seq 1 5); do echo \"Run ${i}\"; java StringTest; done"

результаты :

Run 1
Format = 1290 millisecond
Concatenation = 115 millisecond
String Builder = 130 millisecond

Run 2
Format = 1265 millisecond
Concatenation = 114 millisecond
String Builder = 126 millisecond

Run 3
Format = 1303 millisecond
Concatenation = 114 millisecond
String Builder = 127 millisecond

Run 4
Format = 1297 millisecond
Concatenation = 114 millisecond
String Builder = 127 millisecond

Run 5
Format = 1270 millisecond
Concatenation = 114 millisecond
String Builder = 126 millisecond
9

String.format() - Это больше, чем конкатенация строк. Например, можно отобразить номера в определенной локали с помощью String.format().

однако, если вы не заботитесь о локализации, нет функциональной разницы. Может быть, один быстрее другого, но в большинстве случаев он будет незначительным..

6

Я не делал никаких конкретных критериев, но я думаю, что конкатенация может быть быстрее. Строка.format () создает новый Формататор, который, в свою очередь, создает новый StringBuilder (размером всего 16 символов). Это довольно много накладных расходов, особенно если вы форматируете более длинную строку, и StringBuilder продолжает изменять размер.

однако конкатенация менее полезна и труднее читается. Как всегда, стоит сделать тест на вашем коде, чтобы увидеть, что лучше. Этот различия могут быть незначительными в серверном приложении после загрузки пакетов ресурсов, локалей и т. д. В память и кода.

возможно, в качестве наилучшей практики было бы неплохо создать свой собственный форматер с соответствующим размером StringBuilder (Appendable) и Locale и использовать его, если у вас есть много форматирования.

2

может быть заметная разница.

String.format довольно сложен и использует регулярное выражение внизу, поэтому не делайте его привычкой использовать его везде, но только там, где вам это нужно.

StringBuilder будет на порядок быстрее (как кто-то здесь уже указывал).

2

Как правило, конкатенация строк должна быть предпочтительнее String.format. Последний имеет два основных недостатка:

  1. Он не кодирует строку, которая будет построена в местной манере.
  2. процесс построения закодирован в строку.

по пункту 1 я имею в виду, что невозможно понять, что такое String.format() вызов выполняется за один последовательный проход. При подсчете приходится переходить от строки формата к аргументам и обратно позиция аргументов. Для коротких конкатенаций это не большая проблема. Однако в этих случаях конкатенация строк менее подробна.

по пункту 2 я имею в виду, что важная часть процесса построения закодирована в формат строки (используя DSL). Использование строк для представления кода имеет много недостатков. Он не является по своей сути типобезопасным и усложняет подсветку синтаксиса, анализ кода, оптимизацию и т. д.

конечно, при использовании инструменты или фреймворки, внешние по отношению к языку Java, могут вступать в игру новые факторы.

1

вы не можете сравнивать конкатенацию строк и строку.Формат по этой программе.

вы можете попробовать это также меняя позицию с помощью строки.Форматирование и конкатенация в вашем блоке кода, как показано ниже

public static void main(String[] args) throws Exception {      
  long start = System.currentTimeMillis();

  for( int i=0;i<1000000; i++){
    String s = String.format( "Hi %s; Hi to you %s",i, + i*2);
  }

  long end = System.currentTimeMillis();
  System.out.println("Format = " + ((end - start)) + " millisecond");
  start = System.currentTimeMillis();

  for( int i=0;i<1000000; i++){
    String s = "Hi " + i + "; Hi to you " + i*2;
  }

  end = System.currentTimeMillis();
  System.out.println("Concatenation = " + ((end - start)) + " millisecond") ;
}

вы будете удивлены, увидев, что формат работает здесь быстрее. Это связано с тем, что созданные объекты intial могут не быть освобождены, и может возникнуть проблема с выделением памяти и, следовательно, производительностью.

0