क्या जावा में स्ट्रिंग कॉनटेनटेशन पर String.format का उपयोग करना बेहतर है?


273

String.formatजावा में उपयोग और स्ट्रिंग संघनन के बीच एक बोधगम्य अंतर है ?

मैं उपयोग करता हूं, String.formatलेकिन कभी-कभी फिसल जाता है और एक संघनन का उपयोग करेगा। मैं सोच रहा था कि क्या एक दूसरे से बेहतर था।

जिस तरह से मैं इसे देखता हूं, String.formatआपको स्ट्रिंग को "स्वरूपण" करने में अधिक शक्ति देता है; और संगति का मतलब है कि आपको गलती से अतिरिक्त% s में डालने या एक को गायब करने के बारे में चिंता करने की ज़रूरत नहीं है।

String.format छोटा भी है।

कौन सा अधिक पठनीय है यह इस बात पर निर्भर करता है कि आपका सिर कैसे काम करता है।


मुझे लगता है कि हम MessageFormat.format के साथ जा सकते हैं। अधिक जानकारी के लिए कृपया उत्तर stackoverflow.com/a/56377112/1491414 देखें ।
गनेसा विजयकुमार

जवाबों:


242

मेरा सुझाव है कि इसका उपयोग करना बेहतर है String.format()। मुख्य कारण यह है कि String.format()संसाधन फ़ाइलों से लोड किए गए पाठ के साथ अधिक आसानी से स्थानीयकृत किया जा सकता है, जबकि प्रत्येक भाषा के लिए अलग-अलग कोड के साथ एक नया निष्पादन योग्य उत्पादन किए बिना संघनन को स्थानीय नहीं किया जा सकता है।

यदि आप अपने ऐप के स्थानीय होने की योजना बनाते हैं, तो आपको अपने प्रारूप टोकन के लिए तर्क पदों को निर्दिष्ट करने की आदत में भी शामिल होना चाहिए:

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

इसके बाद स्थानीयकरण किया जा सकता है और अलग-अलग ऑर्डर करने के लिए निष्पादन योग्य की एक recompile की आवश्यकता के बिना नाम और समय की अदला-बदली होती है। तर्क पदों के साथ आप दो बार फ़ंक्शन में पास किए बिना उसी तर्क का फिर से उपयोग कर सकते हैं:

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

1
क्या आप मुझे कुछ दस्तावेज़ों की ओर इशारा कर सकते हैं जो जावा में तर्क पदों / आदेश के साथ काम करने के बारे में बात करते हैं (यानी, उनकी स्थिति से तर्क कैसे संदर्भित करें)? धन्यवाद।
निशान्वती

13
देर से कभी भी बेहतर नहीं, यादृच्छिक जावा संस्करण: docs.oracle.com/javase/1.5.0/docs/api/java/util/…
Aksel

174

प्रदर्शन के बारे में:

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 मिलीसेकंड
  • प्रारूप = 4141 मिलीसेकंड

इसलिए, कंक्रीटिंग String.format की तुलना में बहुत तेज है।


15
वे सभी बुरे अभ्यास हैं। StringBuilder का उपयोग करें।
आमिर रामिनफर

8
StringBuilder यहां स्कोप से बाहर है (ओपी प्रश्न String.format on string Concatenation की तुलना करने के बारे में था) लेकिन क्या आपने स्ट्रिंग बिल्डर के बारे में डेटा का प्रदर्शन किया है?
इकरो

108
@AmirRaminar: संकलक "+" को कॉल करता है स्वचालित रूप से StringBuilder के लिए।
मार्टिन श्रोडर

40
@ MartinSchröder: यदि आप चलाते हैं javap -c StringTest.classतो आप देखेंगे कि कंपाइलर "+" को स्ट्रिंगरबर्स्ट में स्वचालित रूप से तभी परिवर्तित करता है जब आप लूप में नहीं होते हैं। यदि संघनन सभी एक ही लाइन पर किया जाता है, तो यह '+' का उपयोग करने के समान है, लेकिन यदि आप उपयोग करते हैं myString += "morechars";या myString += anotherString;कई लाइनों पर आप ध्यान देंगे कि एक से अधिक स्ट्रिंगबुलस्ट बनाया जा सकता है, इसलिए "+" का उपयोग करना हमेशा उतना कुशल नहीं होता है StringBuilder के रूप में।
ccpizza

7
@ जॉफ्री: मेरा मतलब था कि छोरों के +लिए परिवर्तित नहीं होता है, StringBuilder.append()बल्कि new StringBuilder()प्रत्येक पुनरावृत्ति पर होता है।
ccpizza

39

चूंकि प्रदर्शन के बारे में चर्चा है कि मुझे लगा कि मैं एक तुलना में जोड़ दूंगा जिसमें स्ट्रिंगबर्ल शामिल थे। यह वास्तव में कॉन्कैट से तेज है और, स्वाभाविक रूप से String.format विकल्प है।

सेब की इस तरह की तुलना करने के लिए मैं तुलना करता हूं कि मैं बाहर की बजाय लूप में एक नए स्ट्रिंगबर्ब्यूल को तुरंत हटा देता हूं (यह वास्तव में सिर्फ एक इंस्ट्रूमेंटेशन करने की तुलना में तेजी से होता है जो लूप अपेंडेंट के लिए फिर से जगह आवंटित करने के ओवरहेड के कारण होता है। एक बिल्डर)।

    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 जानकारी [परीक्षण] - प्रारूप = 1416 मिलीसेकंड
  • 2012-01-11 16: 30: 46,190 INFO [TestMain] - कॉनटेनटेनमेंट = 134 मिलीसेकंड
  • 2012-01-11 16: 30: 46,313 जानकारी [टेस्टमैन] - स्ट्रिंग बिल्डर = 117 मिलीसेकंड

21
StringBuilder परीक्षण toString () को कॉल नहीं करता है, इसलिए यह उचित तुलना नहीं है। मुझे लगता है कि यदि आप उस बग को ठीक कर लेते हैं, तो आप समवर्ती के प्रदर्शन की माप त्रुटि के भीतर पाएंगे।
Jamey Sharp

15
संघटन और प्रारूप परीक्षण में, आपने एक के लिए कहा String। StringBuilder परीक्षण, निष्पक्ष होने के लिए, एक अंतिम चरण की आवश्यकता है जो StringBuilder की सामग्री को एक स्ट्रिंग में बदल देता है। तुम बुलाकर ऐसा करते हो bldString.toString()। मुझे आशा है कि यह समझाता है?
Jamey Sharp

4
Jamey Sharp बिल्कुल सही है। BldString.toString () को लागू करना उसी के बारे में है यदि स्ट्रिंग संघनन की तुलना में धीमा नहीं है।
अकोस Cz

3
String s = bldString.toString(); समय संयोजन और stringbuilder लगभग एक-दूसरे के साथ बराबर के साथ थे: Format = 1520 millisecond, Concatenation = 167 millisecond, String Builder = 173 millisecond मैं उन्हें एक पाश में भाग गया और प्रत्येक बाहर एक अच्छा प्रतिनिधि पाने के लिए औसतन: (पूर्व JVM अनुकूलन जब मैं समय मिलता है, एक 10000+ पाश की कोशिश करेंगे)
TechTrip

3
आप लोगों को कैसे पता है कि कोड को पूरी तरह से निष्पादित किया जाता है? चर को कभी पढ़ा या उपयोग नहीं किया जाता है, आप यह सुनिश्चित नहीं कर सकते कि जेआईटी पहली बार में इस कोड को नहीं हटाता है।
अलबोडज़्क

37

इसके साथ एक समस्या .formatयह है कि आप स्थैतिक प्रकार की सुरक्षा खो देते हैं। आपके पास अपने प्रारूप के लिए बहुत कम तर्क हो सकते हैं, और आपके पास प्रारूप निर्दिष्टकर्ताओं के लिए गलत प्रकार हो सकते हैं - दोनों एक IllegalFormatException रनटाइम में अग्रणी हैं , इसलिए आप उत्पादन को तोड़ने वाले लॉगिंग कोड के साथ समाप्त हो सकते हैं।

इसके विपरीत, +संकलक द्वारा परीक्षण किए जा सकने वाले तर्कों का परीक्षण किया जा सकता है।

सुरक्षा इतिहास की(जिस पर formatफ़ंक्शन मॉडलिंग की गई है) लंबी और भयावह है।


16
सिर्फ रिकॉर्ड के लिए, आधुनिक आईडीई (जैसे इंटेलीज) तर्क गिनती और टाइप मिलान में सहायता करते हैं
रॉन क्लेन

2
संकलन के बारे में अच्छी बात है, मैं आपको इन जांचों को FindBugs (जो आईडीई में या निर्माण के दौरान मावेन के माध्यम से चला सकता हूं) के माध्यम से करने की सलाह देता हूं, ध्यान दें कि यह आपके सभी लॉगिंग में स्वरूपण की भी जांच करेगा! यह उपयोगकर्ताओं की परवाह किए बिना काम करता है IDE
Christophe Roussy

20

कौन सा अधिक पठनीय है यह इस बात पर निर्भर करता है कि आपका सिर कैसे काम करता है।

आपको अपना जवाब वहीं मिल गया।

यह व्यक्तिगत स्वाद की बात है।

स्ट्रिंग संघनन थोड़ा तेज है, मुझे लगता है, लेकिन यह नगण्य होना चाहिए।


3
मैं सहमत हूँ। यहां प्रदर्शन के अंतर के बारे में सोचना मुख्य रूप से सिर्फ समय से पहले का अनुकूलन है - जिस अप्रत्याशित घटना से पता चलता है कि प्रोफाइलिंग में यहां कोई समस्या है, तो इसके बारे में चिंता करें।
जोनीक

3
यह वास्तव में केवल व्यक्तिगत स्वाद की बात है अगर परियोजना छोटी है और किसी भी सार्थक अर्थ में अंतर्राष्ट्रीयकरण का इरादा नहीं है। अन्यथा String.format हर तरह से सहमति से अधिक जीतता है।
workmad3

4
मैं असहमत हूं। कोई फर्क नहीं पड़ता कि परियोजना कितनी बड़ी है, आप शायद ही हर स्ट्रिंग को स्थानीय बनाने जा रहे हैं जो कभी भी उसके भीतर निर्मित है। दूसरे शब्दों में, यह स्थिति पर निर्भर करता है (इसके लिए उपयोग किए गए तार क्या हैं)।
जोनीक

मैं कल्पना नहीं कर सकता कि कोई भी कभी भी 'String.format ("% s% s", a, b) को' a + b 'की तुलना में अधिक पठनीय कैसे मान सकता है, और गति में क्रम-परिमाण अंतर को देखते हुए उत्तर मुझे स्पष्ट लगता है (ऐसी परिस्थितियों में जिन्हें स्थानीयकरण की आवश्यकता नहीं होगी जैसे डिबग या अधिकांश लॉगिंग स्टेटमेंट)।
BobDoolittle

16

यहाँ मिलीसेकंड में कई नमूना आकार के साथ एक परीक्षण किया गया है।

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

1
जब आप लूप में पात्रों को जोड़ रहे हैं, तो स्ट्रिंगबर्स्ट पूरी तरह से सबसे तेज़ विधि है, उदाहरण के लिए, जब आप एक-एक करके एक हज़ार 1 के साथ एक स्ट्रिंग बनाना चाहते हैं। यहाँ अधिक जानकारी है: pellegrino.link/2015/08/22/…
कार्लोस होयोस

मुझे यह पसंद है कि आप आउटपुट के लिए हमेशा String.format का उपयोग कैसे करते हैं: D तो एक फायदा है। और ईमानदार होने के लिए अगर हम लाखों पुनरावृत्तियों के बारे में बात नहीं कर रहे हैं, तो मैं पठनीयता के लिए string.format पसंद करता हूं क्योंकि आपका कोड स्पष्ट लाभ दिखाता है!
मुहम्मनाग

9

यहां StringBuilder पर StString () पद्धति को कॉल करने के संशोधन के साथ ऊपर जैसा ही परीक्षण है । नीचे दिए गए परिणाम दर्शाते हैं कि स्ट्रिंगबर्लेस्ट दृष्टिकोण + ऑपरेटर का उपयोग करते हुए स्ट्रिंग संघनन की तुलना में थोड़ा धीमा है ।

फ़ाइल: 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");

  }
}

शैल कमांड: (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

6

String.format()सिर्फ तार को जोड़ने से ज्यादा है। उदाहरण के लिए, आप एक विशिष्ट लोकेल में संख्याओं का उपयोग करके प्रदर्शित कर सकते हैं String.format()

हालांकि, अगर आप स्थानीयकरण की परवाह नहीं करते हैं, तो कोई कार्यात्मक अंतर नहीं है। शायद एक दूसरे की तुलना में तेज है, लेकिन ज्यादातर मामलों में यह नगण्य होगा।


4

आम तौर पर, स्ट्रिंग कॉन्फैनेटेशन को प्राथमिकता दी जानी चाहिए String.format। उत्तरार्द्ध के दो मुख्य नुकसान हैं:

  1. यह स्थानीय तरीके से बनाए जाने वाले स्ट्रिंग को एन्कोड नहीं करता है।
  2. निर्माण प्रक्रिया एक स्ट्रिंग में एन्कोडेड है।

बिंदु 1 से मेरा मतलब है कि यह समझना संभव नहीं है कि String.format()एकल अनुक्रमिक पास में कॉल क्या कर रहा है। तर्कों की स्थिति गिनाते हुए, प्रारूप स्ट्रिंग और तर्कों के बीच आगे और पीछे जाने के लिए मजबूर किया जाता है। लघु सम्मेलनों के लिए, यह एक मुद्दा नहीं है। इन मामलों में, हालांकि, स्ट्रिंग संघनन कम क्रिया है।

बिंदु 2 से, मेरा मतलब है कि निर्माण प्रक्रिया का महत्वपूर्ण हिस्सा प्रारूप स्ट्रिंग (एक डीएसएल का उपयोग करके) में एन्कोडेड है । कोड का प्रतिनिधित्व करने के लिए स्ट्रिंग्स का उपयोग करने के कई नुकसान हैं। यह स्वाभाविक रूप से सुरक्षित नहीं है, और सिंटैक्स-हाइलाइटिंग, कोड विश्लेषण, अनुकूलन, आदि को जटिल बनाता है।

बेशक, जावा भाषा के लिए बाहरी उपकरणों या रूपरेखाओं का उपयोग करते समय, नए कारक खेल में आ सकते हैं।


2

मैंने कोई विशिष्ट बेंचमार्क नहीं किया है, लेकिन मुझे लगता है कि संघनन तेज हो सकता है। String.format () एक नया सूत्र बनाता है, जो बदले में, एक नया StringBuilder (केवल 16 वर्णों के आकार के साथ) बनाता है। यह उचित मात्रा में ओवरहेड है, खासकर यदि आप एक लंबी स्ट्रिंग का प्रारूपण कर रहे हैं और स्ट्रिंगबर्स्ट का आकार बदलता रहता है।

हालांकि, संघनन कम उपयोगी है और पढ़ने में कठिन है। हमेशा की तरह, यह आपके कोड पर एक बेंचमार्क करने लायक है जो बेहतर है। आपके संसाधन बंडलों, स्थानों, आदि को मेमोरी में लोड किए जाने और कोड JITted होने के बाद सर्वर ऐप में अंतर नगण्य हो सकता है।

शायद सबसे अच्छे अभ्यास के रूप में, यह एक अच्छा विचार होगा कि आप अपने फॉर्मैटर को अच्छी तरह से आकार के स्ट्रिंगरब्युल (अपेंडेबल) और लोकेल के साथ बनाएं और इसका उपयोग करें कि यदि आपके पास करने के लिए बहुत कुछ है।


2

एक बोधगम्य अंतर हो सकता है।

String.format काफी जटिल है और नीचे एक नियमित अभिव्यक्ति का उपयोग करता है, इसलिए इसे हर जगह उपयोग करने की आदत न डालें, लेकिन केवल जहां आपको इसकी आवश्यकता है।

StringBuilder तेजी से परिमाण का एक क्रम होगा (जैसा कि यहां किसी ने पहले ही इंगित किया है)।


1

मुझे लगता है कि हम साथ जा सकते हैं MessageFormat.formatक्योंकि यह पठनीयता और प्रदर्शन पहलुओं दोनों पर अच्छा होना चाहिए।

मैंने उसी कार्यक्रम का उपयोग किया, जिसका उपयोग इकरो ने अपने उपरोक्त उत्तर में किया था और मैंने MessageFormatप्रदर्शन संख्याओं की व्याख्या करने के लिए इसका उपयोग कोडिंग कोड के साथ बढ़ाया ।

  public static void main(String[] args) {
    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");

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

संघटन = 69 मिलीसेकंड

प्रारूप = 1435 मिलीसेकंड

MessageFormat = 200 मिलीसेकंड

अद्यतन:

सोनारलिंट की रिपोर्ट के अनुसार, प्रिंटफ-स्टाइल फॉर्मेट स्ट्रिंग्स का सही इस्तेमाल किया जाना चाहिए (स्क्विड: S3457)

क्योंकि printf-styleप्रारूप स्ट्रिंग को संकलक द्वारा मान्य होने के बजाय, रनटाइम पर व्याख्या की जाती है, जिसमें वे त्रुटियां हो सकती हैं, जिसके परिणामस्वरूप गलत तार पैदा हो जाते हैं। यह नियम स्थिर की सह-संबंध की पुष्टि करता है printf-styleजब का स्वरूप (...) तरीकों बुला उनके तर्कों को प्रारूप तार java.util.Formatter, java.lang.String, java.io.PrintStream, MessageFormat, और java.io.PrintWriterवर्गों और printf(...)के तरीकों java.io.PrintStreamया java.io.PrintWriterवर्गों।

मैं घुंघराले ब्रैकेट के साथ प्रिंटफ-स्टाइल को प्रतिस्थापित करता हूं और मुझे नीचे के रूप में कुछ दिलचस्प परिणाम मिले हैं।

संघटन = ६ ९ मिलीसेकेंड
प्रारूप = ११०is मिलीसेकेंड
प्रारूप: घुंघराले-कोष्ठक = ४१६ मिलीसेकेंड
संदेशफ़ॉर्मट = २१५ मिलीसेकंड
संदेश संदेश: घुंघराले-कोष्ठक = २५१is मिलीसेकंड

मेरा निष्कर्ष:
जैसा कि मैंने ऊपर प्रकाश डाला है, घुंघराले-कोष्ठक के साथ String.format का उपयोग करके अच्छी पठनीयता और प्रदर्शन के लाभ प्राप्त करने के लिए एक अच्छा विकल्प होना चाहिए।


0

आप उपरोक्त कार्यक्रम द्वारा स्ट्रिंग कॉन्टेनेशन और String.Format की तुलना नहीं कर सकते हैं।

आप कोशिश कर सकते हैं कि यह आपके स्ट्रिंग का उपयोग करने की स्थिति को इंटरचेंज कर रहा हो। नीचे दिए गए कोड के अनुसार अपने कोड ब्लॉक में पोर्ट्रेट और कॉनटेनेशन करें।

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

आपको यह देखकर आश्चर्य होगा कि प्रारूप यहाँ तेजी से काम करता है। यह तब से है जब बनाई गई अंतरंग वस्तुओं को जारी नहीं किया जा सकता है और मेमोरी आवंटन और इस तरह प्रदर्शन के साथ कोई समस्या हो सकती है।


3
क्या आपने अपना कोड आज़माया है? कॉनकैटेशन हमेशा दस
गुना

इस "System.currentTimeMillis ()" को निष्पादित करने के लिए ली गई मिली के बारे में क्या: पी।
रेहान

0

String.Format की आदत पड़ने में थोड़ा समय लगता है, लेकिन यह ज्यादातर मामलों में इसके लायक है। एनआरए की दुनिया में (कभी भी कुछ भी न दोहराएं) अपने स्थिर संदेशों (लॉगिंग या उपयोगकर्ता) को लगातार लाइब्रेरी में रखना बहुत उपयोगी है (मुझे पसंद है कि एक स्थिर वर्ग के लिए क्या मात्रा है) और उन्हें स्ट्रिंग के साथ आवश्यक रूप से बुलाएं। आप चाहे जो भी हों स्थानीयकरण कर रहे हैं या नहीं। इस तरह के एक पुस्तकालय का उपयोग करने की कोशिश करना एक संगति विधि के साथ पढ़ना, समस्या निवारण, प्रूफरीड करना है, और किसी भी दृष्टिकोण के साथ प्रबंधन करना आवश्यक है, जिसे सहमति की आवश्यकता है। प्रतिस्थापन एक विकल्प है, लेकिन मुझे संदेह है कि यह प्रदर्शनकारी है। उपयोग के वर्षों के बाद, String.Format के साथ मेरी सबसे बड़ी समस्या कॉल की लंबाई असुविधाजनक रूप से लंबी है जब मैं इसे किसी अन्य फ़ंक्शन (जैसे Msg) में पारित कर रहा हूं, लेकिन यह एक उपनाम के रूप में सेवा करने के लिए कस्टम फ़ंक्शन के साथ प्राप्त करना आसान है। ।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.