+ = Concat से अधिक कुशल है?

Question

मैं अपनी टीम पर अन्य डेवलपर्स द्वारा उत्पादित कोड पढ़ रहा हूं, वे स्ट्रिंग कॉन्सटेनेशन के लिए += का उपयोग करने का पक्ष लेते हैं, जबकि मैं .concat() का उपयोग करना पसंद करता हूं क्योंकि इसे पढ़ने में आसान लगता है।

मैंका उपयोग क्यों कर रहा हूं, इस बारे में एक तर्क तैयार करने की कोशिश कर रहा हूं, और मैं सोच रहा हूं, क्या दोनों के बीच दक्षता में कोई अंतर है?

हमें कौन सा विकल्प "लेना चाहिए"?

public class Stuff { 

    public static void main(String[] args) { 

     String hello = "hello "; 
     hello += "world"; 
     System.out.println(hello); 

     String helloConcat = "hello ".concat("world"); 
     System.out.println(helloConcat); 
    } 
} 

Answer 1

स्ट्रिंग के बाद से, जावा में अपरिवर्तनीय है जब आप एक +, += या concat(String) करते हैं, एक नया स्ट्रिंग उत्पन्न होता है । जितना बड़ा स्ट्रिंग उतना लंबा हो जाता है - कॉपी करने के लिए और अधिक कचरा पैदा होता है।

आज के जावा कंपाइलर्स इसे इष्टतम बनाने के लिए आपके स्ट्रिंग कॉन्सटेनेशन को अनुकूलित करते हैं, उदा।

System.out.println((new StringBuilder()).append("x:").append(x).append(" y:").append(y).toString()); 

मेरी सलाह कोड आसान है कि बनाए रखने और पढ़ने के लिए लिखने के लिए है:

System.out.println("x:"+x+" y:"+y); 

संकलक करने के लिए इसे उत्पन्न करता है।

यह लिंक StringBuilder vs StringBuffer vs String.concat - done right

Answer 2

इससे कोई फर्क नहीं पड़ता। आधुनिक दिन जावा कंपाइलर्स, जेवीएम और जेआईटी आपके कोड को इस तरह अनुकूलित करेंगे कि मतभेद न्यूनतम होने की संभावना है। आपको कोड लिखने का प्रयास करना चाहिए जो आपके लिए अधिक पठनीय और रखरखाव योग्य है।

Answer 3

मैं @ darioo और अन्य अन्य उत्तरों से सहमत हूं। हमेशा पठनीयता (और रखरखाव) पहले रखें। (एक आधुनिक जेआईटी कंपाइलर को इन तरह के साधारण मामलों के साथ कोई परेशानी नहीं होनी चाहिए।)

हालांकि आपके प्रोग्राम से संबंधित बाइटकोड है। (ध्यान दें कि एक StringBuilder में += दृष्टिकोण परिणाम जो आम तौर पर पसंद के दृष्टिकोण जब तार का निर्माण है।)

// String hello = "hello"; 
0: ldC#2; //String hello 
2: astore_1 

// hello += "world"; 
3: new #3; //class java/lang/StringBuilder 
6: dup 
7: invokespecial #4; //Method StringBuilder."<init>" 
10: aload_1 
11: invokevirtual #5; //Method StringBuilder.append 
14: ldC#6; //String world 
16: invokevirtual #5; //Method StringBuilder.append 
19: invokevirtual #7; //Method StringBuilder.toString 

// System.out.println(hello); 
22: astore_1 
23: getstatiC#8; //Field System.out 
26: aload_1 
27: invokevirtual #9; //Method PrintStream.println 

// String helloConcat = "hello ".concat("world"); 
30: ldC#2; //String hello 
32: ldC#6; //String world 
34: invokevirtual #10; //Method String.concat 
37: astore_2 

// System.out.println(helloConcat); 
38: getstatiC#8; //Field System.out 
41: aload_2 
42: invokevirtual #9; //Method PrintStream.println 

45: return 

Answer 4

के प्रदर्शन पठनीयता के संदर्भ में पता चलता है, मुझे लगता है कि तुम बहुत गलत हैं। +.concat() से अधिक जीतता है। यदि आप += का उपयोग कर रहे हैं, तो आप लूप के लिए StringBuilder रखते हुए StringBuilder.append के बारे में सोचना चाहेंगे।

प्रदर्शन के संदर्भ में concat+ से बेहतर है। जब तक आप केवल एक या शायद दो का उपयोग करते हैं।

concat के मामले में, आप एक String ऑब्जेक्ट को सही ढंग से आकार char[] के साथ बना देंगे। यह उतना ही इष्टतम है जितना आप प्राप्त कर सकते हैं।

+ के लिए javac कोड उत्पन्न करता है जो StringBuilder को जोड़ने के लिए बनाता है और फिर String में परिवर्तित हो जाता है। 1 से।5 आपके द्वारा बनाए गए:

• एक StringBuilder (अपशिष्ट)
• प्रारंभिक char[]StringBuilder (अपशिष्ट)
• हैं जिसके परिणामस्वरूप अनुक्रम बहुत लंबा है, एक दूसरे बड़ा char[] (अपशिष्ट)
• के लिए जिसके परिणामस्वरूप String।
• String का char[]।

हालांकि, आप शायद ही कभी concat उपयोग करते हैं क्योंकि इसे पढ़ना अधिक कठिन होता है। प्रदर्शन निश्चित रूप से समुद्र में एक बूंद होने जा रहा है, जो कि और क्या हो रहा है (संकेत: अनुकूलन से पहले एक लिफाफे के पीछे आज़माएं)।

Answer 5

आपको जो करना चाहिए वह आपको सबसे छोटा और स्पष्ट होना चाहिए।

हालांकि, आपकी रुचि के लिए।

String hello = "hello " + "world"; 

एक में दो स्ट्रिंग संयुक्त संकलन के रूप में सबसे तेजी से है।

यह दो स्ट्रिंग्स के लिए सबसे तेज़ है क्योंकि यह स्ट्रिंगबिल्डर बनाने से बचाता है।

String helloConcat = "hello ".concat(world); 

हालांकि यदि आपके पास स्ट्रिंगबिल्डर का उपयोग करके दो से अधिक तार हैं, तो या तो स्पष्ट रूप से या स्पष्ट रूप से सबसे तेज़ है।

संक्षेप में मैं + का उपयोग तब तक करूंगा जब तक कि आपके पास लूप में न हो, तब तक मैं स्ट्रिंगबिल्डर का प्रदर्शन स्पष्ट रूप से प्रदर्शन में सुधार करने के लिए कर सकता हूं।

Answer 6

मैं इस artical मिल गया है और इस परीक्षण बना दिया है:

public static void main(String[] args) { 
     String s1 = generateString(); 
     String s2 = generateString(); 
     String s3 = generateString(); 
     String s4 = generateString(); 
     String s5 = generateString(); 
     String s6 = generateString(); 

     long e = System.currentTimeMillis(); 
     for(int i=0;i<10000000;i++){ 
     //StringBuilder > concat> plus >StringBuffer >plusEqual(">"means faster than) 
      //concatPlus(s1 , s2 , s3 , s4 , s5 , s6);//4204ms 
      //concatBuilder(s1 , s2 , s3 , s4 , s5 , s6);//2562ms 
      //concatBuffer(s1 , s2 , s3 , s4 , s5 , s6);//4610ms 
      //concatPlusEqual(s1 , s2 , s3 , s4 , s5 , s6);//9843ms 
      //concatConcat(s1 , s2 , s3 , s4 , s5 , s6);//3036ms 
     } 
     System.out.println(System.currentTimeMillis()-e);   
    } 

public static String concatPlusEqual(String s1, String s2, String s3, String s4, 
     String s5, String s6) { 
     String result = ""; 
     result += s1; 
     result += s2; 
     result += s3; 
     result += s4; 
     result += s5; 
     result += s6; 
     return result; 
} 

    public static String concatConcat(String s1, String s2, String s3, String s4, 
      String s5, String s6) { 
     String result = new String(); 
     result.concat(s1); 
     result.concat(s2); 
     result.concat(s3); 
     result.concat(s4); 
     result.concat(s5); 
     result.concat(s6); 
     return result; 
    } 


    public static String concatBuffer(String s1, String s2, String s3, String s4, 
      String s5, String s6) { 
     return new StringBuffer(s1.length() + s2.length() + s3.length() 
       + s4.length() + s5.length() + s6.length()).append(s1) 
       .append(s2).append(s3).append(s4).append(s5).append(s6) 
       .toString(); 
    } 

    public static String concatBuilder(String s1, String s2, String s3, String s4, 
      String s5, String s6) { 
     return new StringBuilder(s1.length() + s2.length() + s3.length() 
       + s4.length() + s5.length() + s6.length()).append(s1) 
       .append(s2).append(s3).append(s4).append(s5).append(s6) 
       .toString(); 
    } 

    public static String concatPlus(String s1,String s2,String s3,String s4,String s5,String s6) { 
     return s1 + s2 + s3 + s4 + s5 + s6; 
    } 
public static String generateString() 
    { 
     Random rng = new Random(); 
     int length = 10; 
     String characters ="ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
     char[] text = new char[length]; 
     for (int i = 0; i < length; i++) 
     { 
      text[i] = characters.charAt(rng.nextInt(characters.length())); 
     } 
     return new String(text); 
    } 

ऐसा नहीं है कि StringBuilder की तरह दिखता है सबसे तेज है और += सबसे धीमी है। बस संदर्भ के लिए!

Answer 7

Concat निश्चित रूप से दो तार concatination के लिए एक तेजी से विकल्प है, मैं नहीं जानता कि क्यों javac आंतरिक

(new StringBuilder(String.valueOf(s1))).append(s2).toString() 

बजाय

s1.concat(s2) 

के लिए S1 + = s2 का उपयोग करता है। इसी तरह के प्रश्न के उत्तर मेरा उत्तर देखें concatenation operator (+) vs concat()