जावा मल्टीलाइन स्ट्रिंग


516

पर्ल से आ रहा है, मुझे यकीन है कि स्रोत कोड में एक बहु-पंक्ति स्ट्रिंग बनाने का मतलब "यहां-दस्तावेज" याद आ रहा है:

$string = <<"EOF"  # create a three-line string
text
text
text
EOF

जावा में, मुझे हर लाइन पर बोझिल उद्धरण और प्लस संकेत देने होंगे क्योंकि मैं अपने मल्टीलाइन स्ट्रिंग को स्क्रैच से अलग कर सकता हूं।

कुछ बेहतर विकल्प क्या हैं? एक गुण फ़ाइल में मेरे स्ट्रिंग को परिभाषित करें?

संपादित करें : दो उत्तर कहते हैं कि StringBuilder.append () प्लस अंकन के लिए बेहतर है। क्या कोई इस बारे में विस्तार से बता सकता है कि वे ऐसा क्यों सोचते हैं? यह मेरे लिए अधिक बेहतर नहीं लगता है। मैं इस तथ्य के इर्द-गिर्द एक रास्ता तलाश रहा हूं कि मल्टीलाइन स्ट्रिंग्स एक प्रथम श्रेणी की भाषा का निर्माण नहीं है, जिसका अर्थ है कि मैं निश्चित रूप से एक प्रथम श्रेणी के भाषा निर्माण (प्लस के साथ स्ट्रिंग संयोजन) को बदलना नहीं चाहता हूं।

संपादित करें : अपने प्रश्न को और स्पष्ट करने के लिए, मुझे प्रदर्शन के बारे में बिल्कुल चिंता नहीं है। मैं स्थिरता और डिजाइन के मुद्दों के बारे में चिंतित हूं।


12
StringBuilder.append () बार-बार स्ट्रिंग में जोड़ते समय प्लस के लिए बेहतर होता है क्योंकि हर बार जब आप string1 + string2एक नई स्ट्रिंग ऑब्जेक्ट आवंटित करते हैं और दोनों इनपुट स्ट्रिंग्स से वर्णों की प्रतिलिपि बनाते हैं। यदि आप n स्ट्रिंग्स को एक साथ जोड़ रहे हैं, तो आप n-1 आवंटन और लगभग (n ^ 2) / 2 वर्ण प्रतियाँ कर रहे हैं। StringBuilder, दूसरी ओर, प्रतियां और reallocates कम बार (हालांकि यह अभी भी दोनों करता है जब आप इसके आंतरिक बफर के आकार से अधिक हो जाते हैं)। सैद्धांतिक रूप से, ऐसे मामले हैं जहां संकलक + को स्ट्रिंगबर्ल का उपयोग करने के लिए परिवर्तित कर सकता है लेकिन व्यवहार में कौन जानता है।
लारेंस गोन्साल्व्स

5
हर बार जब मैं डीबगर में कूदता हूं, तो जावा 1.5 पर + को एक StringBuilder.append () कॉल में बदल दिया जाता है। मैंने सहकर्मियों को भ्रमित करने के लिए कहा है कि स्ट्रिंगब्यूरीस्टल में एक बग है क्योंकि वे कोड में डिबग करते हैं जो इसे कॉल करने और वहां हवा देने के लिए प्रकट नहीं होता है।
स्किप्पॉपी


61
ध्यान दें कि एक स्ट्रिंग शाब्दिक "abc \ n" + "def \ n" आदि से बना है, StringBuilder का उपयोग नहीं करता है: संकलक उन्हें एक साथ glues करते हैं और उन्हें एक एकल शाब्दिक के रूप में .class फ़ाइल में डालते हैं, अन्य प्रकार के समान। निरंतर तह।
araqnid

6
अधिकांश IDE मल्टी-लाइन स्ट्रिंग्स में प्रवेश करने का समर्थन करते हैं। अर्थात। आप बस एक टाइप करें या पेस्ट करें जो आप "" स्ट्रिंग में चाहते हैं और यह आवश्यकतानुसार \ n और "+" जोड़ देगा। उदाहरण के लिए मैं एक स्ट्रिंग में पाठ की 40 पंक्तियाँ चिपका सकता हूँ और आपके लिए यह आईडीई छांटता है।
पीटर लॉरी

जवाबों:


118

स्टीफन कोलबोर्न ने जावा 7 में मल्टी-लाइन स्ट्रिंग्स को जोड़ने के लिए एक प्रस्ताव बनाया है ।

साथ ही, ग्रूवी के पास पहले से ही मल्टी-लाइन स्ट्रिंग्स के लिए समर्थन है ।


14
जावा के संवर्द्धन के लिए प्रोजेक्ट कॉइन प्रक्रिया में मल्टी लाइन स्ट्रिंग्स mail.openjdk.java.net/pipermail/coin-dev/2009-Febdays/… शामिल थे । इसे Oracle ब्लॉगs.sun.com/darcy/entry/project_coin_final_five ने अस्वीकार कर दिया था ।
JodaStephen

8
2012 में कोई बदलाव?
इलिया जी

13
दुर्भाग्य से यह प्रतीत नहीं होता है कि यह कल्पना में बना है।
नामुएल

3
Blogs.sun.com लिंक टूट गया है, लेकिन मुझे लगता है कि सामग्री अब blogs.oracle.com/darcy/entry/project_coin_final_five पर है ।
डोनाल्ड फेलो

8
लगता है, जनवरी 2018 तक, समुदाय मल्टी-लाइन स्ट्रिंग्स पर फिर से विचार कर रहा है। openjdk.java.net/jeps/326
शेन

485

ऐसा लगता है कि आप एक मल्टीलाइन शाब्दिक करना चाहते हैं, जो जावा में मौजूद नहीं है।

आपका सबसे अच्छा विकल्प स्ट्रिंग्स बनने जा रहा है जो सिर्फ +एक साथ हैं। कुछ अन्य विकल्पों का लोगों ने उल्लेख किया है (StringBuilder, String.format, String.join) केवल तभी बेहतर होगा जब आप स्ट्रिंग की एक सरणी के साथ शुरू करेंगे।

इस पर विचार करो:

String s = "It was the best of times, it was the worst of times,\n"
         + "it was the age of wisdom, it was the age of foolishness,\n"
         + "it was the epoch of belief, it was the epoch of incredulity,\n"
         + "it was the season of Light, it was the season of Darkness,\n"
         + "it was the spring of hope, it was the winter of despair,\n"
         + "we had everything before us, we had nothing before us";

बनाम StringBuilder:

String s = new StringBuilder()
           .append("It was the best of times, it was the worst of times,\n")
           .append("it was the age of wisdom, it was the age of foolishness,\n")
           .append("it was the epoch of belief, it was the epoch of incredulity,\n")
           .append("it was the season of Light, it was the season of Darkness,\n")
           .append("it was the spring of hope, it was the winter of despair,\n")
           .append("we had everything before us, we had nothing before us")
           .toString();

बनाम String.format():

String s = String.format("%s\n%s\n%s\n%s\n%s\n%s"
         , "It was the best of times, it was the worst of times,"
         , "it was the age of wisdom, it was the age of foolishness,"
         , "it was the epoch of belief, it was the epoch of incredulity,"
         , "it was the season of Light, it was the season of Darkness,"
         , "it was the spring of hope, it was the winter of despair,"
         , "we had everything before us, we had nothing before us"
);

बनाम जावा 8 String.join():

String s = String.join("\n"
         , "It was the best of times, it was the worst of times,"
         , "it was the age of wisdom, it was the age of foolishness,"
         , "it was the epoch of belief, it was the epoch of incredulity,"
         , "it was the season of Light, it was the season of Darkness,"
         , "it was the spring of hope, it was the winter of despair,"
         , "we had everything before us, we had nothing before us"
);

आप अपने विशेष प्रणाली के लिए न्यू लाइन चाहते हैं, आप उपयोग करने के लिए या तो की जरूरत System.lineSeparator()है, या आप उपयोग कर सकते हैं %nमें String.format

एक अन्य विकल्प संसाधन को एक टेक्स्ट फ़ाइल में डालना है, और बस उस फ़ाइल की सामग्री को पढ़ना है। यह बहुत बड़ी स्ट्रिंग्स के लिए बेहतर होगा कि आप अपनी क्लास की फाइलों को अनावश्यक रूप से फोड़ने से बचें।


246
इसके अलावा, पहले संस्करण को संकलक द्वारा स्वचालित रूप से संक्षिप्त किया जाएगा, क्योंकि सभी तार संकलन समय पर जाने जाते हैं। यहां तक ​​कि अगर तार संकलन समय पर ज्ञात नहीं हैं, तो यह StringBuilder या String.format () की तुलना में कोई धीमा नहीं है। यदि आप इसे लूप में कर रहे हैं, तो केवल + के साथ संगति से बचने का एकमात्र कारण है।
माइकल मायर्स

23
String.formatसंस्करण के साथ समस्या यह है कि आपको लाइनों की संख्या के साथ प्रारूप को सिंक में रखना होगा।
बार्ट वैन ह्युकेलोम

4
अन्य दो उदाहरणों की तुलना में
String.format

10
यह जवाब हाथ में लिए सवाल का एक बहुत ही अनुचित समाधान है। हमारे पास 2000 लाइन एसएएस मैक्रोज़ या 200 लाइन एसक्यूएल प्रश्नों का गुच्छा है जिसे हम कॉपी और पेस्ट करना चाहते हैं। यह सुझाव देने के लिए कि हम उन बहुस्तरीय पाठ को स्ट्रिंगबर्गर अपेंडिक्स में बदलने के लिए + "" कॉन्कट का उपयोग करते हैं, हास्यास्पद है।
धन्य गीक

21
@BlessedGeek: हाथ में सवाल यह था कि जावा भाषा में कौन से विकल्प उपलब्ध थे। यह स्ट्रिंग में जाने वाले डेटा के प्रकार के बारे में कुछ भी उल्लेख नहीं करता है। यदि कोई बेहतर उपाय है तो आप इसे उत्तर के रूप में पोस्ट कर सकते हैं। ऐसा लगता है कि जोश क्यूरेन का समाधान आपकी स्थिति के लिए बेहतर होगा। यदि आप सिर्फ इस बात से परेशान हैं कि भाषा बहुस्तरीय शाब्दिक का समर्थन नहीं करती है, तो इसके बारे में शिकायत करने के लिए यह गलत जगह है।
किप

188

ग्रहण में यदि आप एक स्ट्रिंग शाब्दिक में चिपकाते हुए "एस्केप टेक्स्ट" विकल्प पर मुड़ते हैं (वरीयताएँ> जावा> संपादक> टाइपिंग में) और एक बहु-पंक्ति स्ट्रिंग व्हिटिन उद्धरण पेस्ट करें, यह स्वचालित रूप से "और \n" +आपकी सभी लाइनों के लिए जोड़ देगा ।

String str = "paste your text here";

15
जब आप "s
Bob B

क्या आप आम तौर पर \rउस ग्रहण को छोड़ते हैं जिसे ग्रहण विंडोज पर डालता है?
नौमेनन

99

यह एक पुराना धागा है, लेकिन एक नया काफी सुरुचिपूर्ण समाधान (केवल 4 शायद 3 छोटी कमियों के साथ) एक कस्टम एनोटेशन का उपयोग करना है।

जाँच करें: http://www.adrianwalker.org/2011/12/java-multiline-string.html

उस काम से प्रेरित एक प्रोजेक्ट GitHub पर होस्ट किया गया है:

https://github.com/benelog/multiline

जावा कोड का उदाहरण:

import org.adrianwalker.multilinestring.Multiline;
...
public final class MultilineStringUsage {

  /**
  <html>
    <head/>
    <body>
      <p>
        Hello<br/>
        Multiline<br/>
        World<br/>
      </p>
    </body>
  </html>
  */
  @Multiline
  private static String html;

  public static void main(final String[] args) {
    System.out.println(html);
  }
}

कमियां हैं

  1. कि आप इसी (प्रदान) एनोटेशन प्रोसेसर को सक्रिय करने के लिए है।
  2. स्ट्रिंग चर को स्थानीय चर के रूप में परिभाषित नहीं किया जा सकता है कच्चे स्ट्रिंग साहित्य की जाँच करें जहाँ आप चर को स्थानीय चर के रूप में परिभाषित कर सकते हैं
  3. उस स्ट्रिंग में Visual Basic .Net के रूप में XML शाब्दिक ( <%= variable %>) :-) के साथ अन्य चर नहीं हो सकते
  4. स्ट्रिंग स्ट्रिंग शाब्दिक JavaDoc टिप्पणी (/ **) द्वारा सीमांकित है

और आपको संभवतः एक्वाज / इन्टेलिज-आइडिया को कॉन्फ़िगर करना होगा, न कि आपके जावेदोक टिप्पणियों को सुधारने के लिए।

किसी को यह अजीब लग सकता है (Javadoc टिप्पणियों को टिप्पणियों के अलावा कुछ भी एम्बेड करने के लिए डिज़ाइन नहीं किया गया है), लेकिन जैसा कि जावा में मल्टीलाइन स्ट्रिंग की कमी वास्तव में अंत में कष्टप्रद है, मुझे लगता है कि यह सबसे कम समाधान है।


क्या मल्टीलाइन स्ट्रिंग का उपयोग करके कक्षा को अंतिम होना आवश्यक है? इसके अलावा, ग्रहण से कोड विकसित और निष्पादित करते समय किसी भी सेटअप की आवश्यकता होती है? संदर्भ URL में एनोटेशन प्रसंस्करण के लिए मावेन के लिए सेटअप आवश्यकताओं का उल्लेख है। मैं यह पता नहीं लगा सकता कि क्या जरूरत हो सकती है, यदि किसी भी ग्रहण में।
डेविड

एनोटेशन जीवंत है - लेकिन ऐसा लगता है कि मावेन पर भी निर्भरता थी? यह हिस्सा हेरेडोक के मूल्य को बहुत दूर ले जाता है जो पाठ के छोटे टुकड़ों के प्रबंधन को सरल बनाने के लिए हैं।
जावदबा

3
आप इसे पूरी तरह से ग्रहण में कर सकते हैं। @SRG के ऊपर पोस्ट किया गया लिंक आपको इस लिंक की ओर इशारा करता है । यदि आप ग्रहण का उपयोग कर रहे हैं, तो सेटअप का एक मिनट और यह काम कर रहा है।
माइकल प्लॉटज़

4
यह शायद मैंने अब तक देखी सबसे बड़ी हैक है। EDIT: नेवरमाइंड ... देखिए बॉब अलब्राइट्स का जवाब।
लेलेव वालिस

1
मैंने इस परियोजना का एक विस्तार किया, एक नया बनाया जो स्थानीय चर समर्थित हैं, इस परियोजना पर एक नज़र डालें
deFreitas

62

एक अन्य विकल्प बाहरी फ़ाइल में लंबे तार को संग्रहीत करना और फ़ाइल को स्ट्रिंग में पढ़ना हो सकता है।


13
बिल्कुल सही। बड़ी मात्रा में पाठ जावा स्रोत में नहीं हैं; Class.getResource (स्ट्रिंग) पर कॉल के माध्यम से लोड करने के बजाय एक उपयुक्त प्रारूप की संसाधन फ़ाइल का उपयोग करें।
एरिकसन

5
सही! आप आसानी से I18N टेक्स्ट को लोड करने के लिए Locale + ResourceBundle का भी उपयोग कर सकते हैं, और फिर String.format () कॉल "\ n" के न्यूलाइंस के रूप में पार्स करेगा :) उदाहरण: स्ट्रिंग रेडीस्ट्र = String .parse (resourceBundle.getString (") परिचय"));
एटोरस

62
आपको एक स्ट्रिंग को केवल इसलिए बाहरी नहीं करना चाहिए क्योंकि यह बहु-पंक्ति है। क्या होगा यदि मेरे पास एक regex है जिसे मैं टिप्पणियों के साथ कई लाइनों में तोड़ना चाहता हूं? यह जावा में बदसूरत दिखता है। @सी # के लिए वाक्यविन्यास अधिक स्वच्छ है।
जेरेमी स्टीन

8
स्किपहॉपी केवल पैराग्राफ लंबाई स्ट्रिंग स्थिरांक का उपयोग करने के लिए फ़ाइलों से निपटने के ओवरहेड के साथ परेशान नहीं करना चाहता है। मैं अपने स्रोत कोड में एम्बेडेड C ++ में हर समय मल्टीलाइन स्ट्रिंग्स का उपयोग करता हूं, जहां मैं उन्हें चाहता हूं।
टिम कूपर

9
वाह। मुझे विश्वास नहीं हो रहा है कि C ++ वास्तव में इस मुद्दे पर जावा से बेहतर है! मुझे मल्टी-लाइन स्ट्रिंग स्थिरांक पसंद हैं और वे कुछ मामलों में स्रोत से संबंधित हैं।
उपयोगकर्ता 1

59

यह कुछ ऐसा है जिसे आपको यह सोचने के बिना कभी भी उपयोग नहीं करना चाहिए कि यह क्या कर रहा है। लेकिन एक-बंद स्क्रिप्ट के लिए मैंने इसे बड़ी सफलता के साथ उपयोग किया है:

उदाहरण:

    System.out.println(S(/*
This is a CRAZY " ' ' " multiline string with all sorts of strange 
   characters!
*/));

कोड:

// From: http://blog.efftinge.de/2008/10/multi-line-string-literals-in-java.html
// Takes a comment (/**/) and turns everything inside the comment to a string that is returned from S()
public static String S() {
    StackTraceElement element = new RuntimeException().getStackTrace()[1];
    String name = element.getClassName().replace('.', '/') + ".java";
    StringBuilder sb = new StringBuilder();
    String line = null;
    InputStream in = classLoader.getResourceAsStream(name);
    String s = convertStreamToString(in, element.getLineNumber());
    return s.substring(s.indexOf("/*")+2, s.indexOf("*/"));
}

// From http://www.kodejava.org/examples/266.html
private static String convertStreamToString(InputStream is, int lineNum) {
    /*
     * To convert the InputStream to String we use the BufferedReader.readLine()
     * method. We iterate until the BufferedReader return null which means
     * there's no more data to read. Each line will appended to a StringBuilder
     * and returned as String.
     */
    BufferedReader reader = new BufferedReader(new InputStreamReader(is));
    StringBuilder sb = new StringBuilder();

    String line = null; int i = 1;
    try {
        while ((line = reader.readLine()) != null) {
            if (i++ >= lineNum) {
                sb.append(line + "\n");
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    return sb.toString();
}

15
अंतिम बाइनरी के साथ वर्ग के लिए जावा कोड को शिपिंग करने की आवश्यकता है। हम्म।
थोरबजोरन रेव एंडरसन

23
मैं अपने सहकर्मियों की प्रतिक्रिया की कल्पना कर सकता हूं जब मैं कुछ इस तरह की जांच करने की कोशिश करता हूं ...
लंडन कुह्न

15
+1। वोट देने वाले व्यक्तियों द्वारा कल्पना की कुछ कमी। यह छोटे उपयोगिताओं, परीक्षण मामलों और यहां तक ​​कि नियंत्रित ठिकानों के वातावरण में लिखने के लिए एक उपयोगी निर्माण है। यह जावा को रूबी / अजगर / आदि में छोड़ने या यहां रहने के बीच एक अंतर निर्माता है।
जावदबा

1
महान समाधान, लेकिन दुर्भाग्य से एंड्रॉइड के लिए काम नहीं करेगा क्योंकि यह एमुलेटर या वास्तविक डिवाइस पर निष्पादित किया जाएगा और वहां कोई स्रोत कोड नहीं है।
evgeny.myasishchev

शायद इसकी एक जावा 8 प्रोब, या कुछ और, लेकिन उदाहरण में classLoader मौजूद नहीं है। मैंने MyClass.class.getResourceAsStream (...) का उपयोग करने की कोशिश की, लेकिन यह हमेशा शून्य देता है। परीक्षण के लिए एक महान त्वरित समाधान होगा!
निक

54

String.join

जावा 8 ने एक नई स्थैतिक विधि जोड़ी, java.lang.Stringजिसमें थोड़ा बेहतर विकल्प मिलता है:

String.join( CharSequence delimiter , CharSequence... elements )

उसका इस्तेमाल कर रहे हैं:

String s = String.join(
    System.getProperty("line.separator"),
    "First line.",
    "Second line.",
    "The rest.",
    "And the last!"
);

5
साफ और स्वच्छ समाधान! आईडीई और प्रीप्रोसेसर पर कोई निर्भरता नहीं! कोई मैनुअल "\n"की जरूरत नहीं है, और पोर्टेबिलिटी के बारे में पता है!
सियु चिंग पोंग -आसुका केंजी-

1
मैं समझता हूं कि मेरी टिप्पणी बेकार है, लेकिन यह एक बहुस्तरीय स्ट्रिंग वायरल के रूप में इस तरह की बुनियादी चीज़ के लिए हैक करने के लिए बहुत पीछे है। क्यों बिल्ली अभी भी कल्पना में जोड़ नहीं सकता है?
दिमित्री

22

JEP 355: टेक्स्ट ब्लॉक (पूर्वावलोकन) का उद्देश्य इस कार्यक्षमता को कवर करना है, यह वर्तमान में पूर्वावलोकन सुविधा के रूप में JDK 13 को लक्षित कर रहा है । कुछ लिखने की अनुमति:

String s = """
    text
    text
    text
  """;

इस JEP से पहले, JDK12 में, JEP 326: रॉ स्ट्रिंग लिटरल्स का उद्देश्य एक समान सुविधा को लागू करना था, लेकिन अंत में इसे वापस ले लिया गया।


2
उन्होंने इस समर्थन को गिरा दिया
deFreitas

2
पाठ ब्लॉक अब Java 13.
ZhekaKozlov

19

यदि आप एक गुण फ़ाइल में अपने तार को परिभाषित करते हैं तो यह बहुत बुरा लगेगा। IIRC, ऐसा दिखेगा:

string:text\u000atext\u000atext\u000a

आम तौर पर स्रोत के लिए बड़े तार को एम्बेड नहीं करना एक उचित विचार है। आप उन्हें संसाधनों के रूप में लोड करना चाह सकते हैं, शायद एक्सएमएल या एक पठनीय पाठ प्रारूप में। पाठ फ़ाइलों को रनटाइम पर पढ़ा जा सकता है या जावा स्रोत में संकलित किया जा सकता है। यदि आप उन्हें स्रोत में रखते हुए समाप्त करते हैं, तो मेरा सुझाव है +कि सामने की ओर और अनावश्यक नई लाइनों को छोड़ दें:

final String text = ""
    +"text "
    +"text "
    +"text"
;

यदि आपके पास नई लाइनें हैं, तो आप कुछ विधि या प्रारूपण विधि से जुड़ सकते हैं:

final String text = join("\r\n"
    ,"text"
    ,"text"
    ,"text"
);

17

प्लसस को स्ट्रिंगब्यूएस्टल.पेंड में बदल दिया जाता है, सिवाय इसके कि जब दोनों तार स्थिर होते हैं तो कंपाइलर उन्हें कंपाउंडिंग समय पर जोड़ सकते हैं। कम से कम, यह है कि यह सूर्य के संकलक में कैसा है, और मुझे सबसे अधिक संदेह होगा कि अन्य सभी संकलक ऐसा नहीं करेंगे।

इसलिए:

String a="Hello";
String b="Goodbye";
String c=a+b;

सामान्य रूप से ठीक उसी कोड को उत्पन्न करता है:

String a="Hello";
String b="Goodbye":
StringBuilder temp=new StringBuilder();
temp.append(a).append(b);
String c=temp.toString();

दूसरी ओर:

String c="Hello"+"Goodbye";

के समान है:

String c="HelloGoodbye";

यही है, पठनीयता के लिए प्लस संकेत के साथ कई लाइनों में अपने स्ट्रिंग शाब्दिक को तोड़ने में कोई जुर्माना नहीं है।


4
तकनीकी होने के लिए, आपके पहले उदाहरण में यह कुछ और उत्पन्न करता है: स्ट्रिंग c = new StringBuilder (); परिशिष्ट (a) .append (b) .toString (); अंतर यह है कि अस्थायी स्ट्रिंग बिल्डर दायरे से बाहर है और स्ट्रिंग सी = ... लाइन के तुरंत बाद कचरा संग्रह के लिए पात्र है, जबकि "टेम्प" स्ट्रिंग बिल्डर थोड़े लंबे समय तक रहेगा।
किप

सच। मेरी बात, निश्चित रूप से यह भेद करना है कि कोई फ़ंक्शन रन-टाइम बनाम जब काम संकलन समय पर किया जा सकता है। लेकिन आप सही हैं।
जय

15

IntelliJ IDE में आपको बस टाइप करना होगा:

""

फिर अपने कर्सर को उद्धरण चिह्नों के अंदर रखें और अपना स्ट्रिंग पेस्ट करें। आईडीई इसे कई संक्षिप्त लाइनों में विस्तारित करेगा।


11

अफसोस की बात है कि जावा में मल्टी-लाइन स्ट्रिंग शाब्दिक नहीं हैं। आपको या तो स्ट्रिंग शाब्दिकों का उपयोग करना होगा (+ का उपयोग करके या स्ट्रिंगबर्ल्ट इस पर दो सबसे आम दृष्टिकोण हैं) या एक अलग फाइल से स्ट्रिंग को पढ़ें।

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

मान लीजिए आप फू नामक एक वर्ग में हैं। बस कुछ इस तरह से करें:

Reader r = new InputStreamReader(Foo.class.getResourceAsStream("filename"), "UTF-8");
String s = Utils.readAll(r);

एक अन्य झुंझलाहट यह है कि जावा में एक मानक नहीं है "इस पाठक के सभी पाठ को एक स्ट्रिंग" विधि में पढ़ें। हालांकि यह लिखना बहुत आसान है:

public static String readAll(Reader input) {
    StringBuilder sb = new StringBuilder();
    char[] buffer = new char[4096];
    int charsRead;
    while ((charsRead = input.read(buffer)) >= 0) {
        sb.append(buffer, 0, charsRead);
    }
    input.close();
    return sb.toString();
}

मैं भी ऐसा ही करता हूं। आप फ़ाइल की सामग्री ("FileUtils.readFileToString (फ़ाइल फ़ाइल)" के साथ) और अधिक आसानी से पढ़ने के लिए कॉमन्स-आईओओ का उपयोग कर सकते हैं।
SRG

नहीं सच के बारे में जावा अब सभी पाठ विधि एक मानक पढ़ा नहीं है ... - जावा 7 के बाद से आप Files.readAllLines (पथ) का उपयोग कर सकते हैं
ccpizza

10
String newline = System.getProperty ("line.separator");
string1 + newline + string2 + newline + string3

लेकिन, String.format का उपयोग करने के लिए सबसे अच्छा विकल्प है

String multilineString = String.format("%s\n%s\n%s\n",line1,line2,line3);

मेरी राय है कि यह प्लस संकेतों और उद्धरणों को हटा देता है, इसे और अधिक पठनीय बनाता है, खासकर जब सिर्फ 3 पंक्तियों से अधिक हो। हालांकि String.format जितना अच्छा नहीं है।
टॉम

2
स्ट्रिंगर का उदाहरण कम से कम अपठनीय है। इसके अलावा, यह मत भूलो कि "\ n" हमेशा एक नई रेखा नहीं होती है, लेकिन यह लिनक्स और यूनिक्स मशीनों के लिए ठीक है।
स्टीफन थ्यबर्ग

इसके अलावा, केवल स्ट्रिंगबर्ल की मौजूदगी का उल्लेख करना चाहता था।
टॉम

4
छह अक्षरों वाली विधि नाम और कोष्ठक के साथ एक से अधिक चिह्न को बदलना मेरे लिए अधिक पठनीय नहीं लगता है, हालांकि स्पष्ट रूप से आप इस तरह से सोचने वाले एकमात्र व्यक्ति नहीं हैं। हालांकि यह उद्धरण नहीं हटाता है। वे अभी भी वहीं हैं।
स्किप्पॉपी

9

चूंकि जावा (अभी तक) मूल समर्थन मल्टी-लाइन स्ट्रिंग्स नहीं करता है, अब इसके लिए एकमात्र तरीका उपरोक्त तकनीकों में से एक का उपयोग करके इसके चारों ओर हैक करना है। मैंने ऊपर वर्णित कुछ चालों का उपयोग करते हुए निम्नलिखित पायथन लिपि का निर्माण किया:

import sys
import string
import os

print 'new String('
for line in sys.stdin:
    one = string.replace(line, '"', '\\"').rstrip(os.linesep)
    print '  + "' + one + ' "'
print ')'

उस फ़ाइल को javastringify.py नाम की एक फ़ाइल में रखें और अपने स्ट्रिंग को एक फ़ाइल मेंringring.txt और निम्नानुसार चलाएं:

cat mystring.txt | python javastringify.py

फिर आप आउटपुट को कॉपी कर सकते हैं और अपने संपादक में पेस्ट कर सकते हैं।

किसी भी विशेष मामलों को संभालने के लिए आवश्यकतानुसार इसे संशोधित करें लेकिन यह मेरी आवश्यकताओं के लिए काम करता है। उम्मीद है की यह मदद करेगा!


9

आप स्कैला-कोड का उपयोग कर सकते हैं, जो जावा के अनुकूल है, और मल्टीलाइन-स्ट्रिंग्स को "":

package foobar
object SWrap {
  def bar = """John said: "This is
  a test
  a bloody test,
  my dear." and closed the door.""" 
}

(स्ट्रिंग के अंदर उद्धरण पर ध्यान दें) और जावा से:

String s2 = foobar.SWrap.bar ();

क्या यह अधिक आरामदायक है ...?

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

sed '1s/^/String s = \"/;2,$s/^/\t+ "/;2,$s/$/"/' file > file.java

ताकि आप इसे आसानी से अपने स्रोत में काट सकें और चिपका सकें।


8

आप एक अलग तरीके से अपने एपेंडेंट को अलग कर सकते हैं जैसे:

public static String multilineString(String... lines){
   StringBuilder sb = new StringBuilder();
   for(String s : lines){
     sb.append(s);
     sb.append ('\n');
   }
   return sb.toString();
}

किसी भी तरह से, StringBuilderप्लस नोटेशन को प्राथमिकता दें।


5
मैं प्लस नोटेशन को स्ट्रिंगबर्ल क्यों पसंद करता हूं?
स्किप्पॉपी

10
दक्षता, या बल्कि अक्सर गुमराह करने का प्रयास।
माइकल मायर्स

2
दक्षता पर प्रयास आधारित है, मुझे लगता है, इस तथ्य पर कि जावा कंपाइलर स्ट्रिंग कंक्रीटिंग ऑपरेटर का उपयोग स्ट्रिंगरब्युटरी (पूर्व 1.5 संकलक में स्ट्रिंगबर्फर) का उपयोग करके करता है। एक पुराना, लेकिन प्रसिद्ध लेख है, जिसमें कहा गया है कि कुछ स्थितियों में StringBuffer (या StringBuilder, अब) का उपयोग करने के लिए प्रदर्शन लाभ हैं। यहाँ लिंक है: java.sun.com/developer/JDCTechTips/2002/tt0305.html
पॉल मोरी

4
केवल जब कंपाइलर ऐसा नहीं कर सकता। शाब्दिक और स्थिरांक के लिए, यदि आप एक प्लस चिह्न का उपयोग करते हैं, तो संघनन संकलन-समय पर किया जाता है। StringBuilder का उपयोग यह रनटाइम पर होने के लिए मजबूर करता है, इसलिए यह केवल अधिक काम नहीं है, यह धीमा है।
जौनी

7

दरअसल, निम्नलिखित सबसे साफ कार्यान्वयन है जो मैंने अब तक देखा है। यह एक टिप्पणी को एक स्ट्रिंग चर में परिवर्तित करने के लिए उपयोग करता है ...

/**
  <html>
    <head/>
    <body>
      <p>
        Hello<br/>
        Multiline<br/>
        World<br/>
      </p>
    </body>
  </html>
  */
  @Multiline
  private static String html;

तो, अंतिम परिणाम यह है कि चर html में मल्टीलाइन स्ट्रिंग शामिल है। कोई उद्धरण, कोई प्लस, कोई अल्पविराम, सिर्फ शुद्ध स्ट्रिंग।

यह समाधान निम्नलिखित URL पर उपलब्ध है ... http://www.adrianwalker.org/2011/12/java-multiline-string.html

उम्मीद है की वो मदद करदे!


एनोटेशन प्रोसेसर को और अधिक मजबूत जाँच की आवश्यकता है,
ट्रिप काइनेटिक्स

यह मुझे पंसद है। इसे
आज़माते

7

जावा स्ट्रिंगफियर देखें । यदि आवश्यक हो तो बचने के लिए अपने पाठ को एक स्ट्रिंगबर्ल जावा ब्लॉक में बदल देता है।


1
हां, क्योंकि मैं अपनी जिंदगी की कॉपी और उस साइट को पेस्ट कर सकता हूं। मैं भी बस उन्हें एक फ़ाइल में संग्रहीत कर सकता हूं और लोड कर सकता हूं लेकिन यह एक आदर्श समाधान भी नहीं है।
mmm

7
    import org.apache.commons.lang3.StringUtils;

    String multiline = StringUtils.join(new String[] {
        "It was the best of times, it was the worst of times ", 
        "it was the age of wisdom, it was the age of foolishness",
        "it was the epoch of belief, it was the epoch of incredulity",
        "it was the season of Light, it was the season of Darkness",
        "it was the spring of hope, it was the winter of despair",
        "we had everything before us, we had nothing before us",
        }, "\n");

6

एक विकल्प जिसे मैंने अभी तक उत्तर के रूप में नहीं देखा है वह है java.io.PrintWriter

StringWriter stringWriter = new StringWriter();
PrintWriter writer = new PrintWriter(stringWriter);
writer.println("It was the best of times, it was the worst of times");
writer.println("it was the age of wisdom, it was the age of foolishness,");
writer.println("it was the epoch of belief, it was the epoch of incredulity,");
writer.println("it was the season of Light, it was the season of Darkness,");
writer.println("it was the spring of hope, it was the winter of despair,");
writer.println("we had everything before us, we had nothing before us");
String string = stringWriter.toString();

इसके अलावा java.io.BufferedWriterएक newLine()विधि है तथ्य यह है कि unmentioned है।


5

यदि आप Google के अमरूद को जितना पसंद करते हैं, उतना ही यह एक साफ सुथरा प्रतिनिधित्व और आपके नए वर्णों को भी हार्डकोड नहीं करने का एक अच्छा, आसान तरीका दे सकता है:

String out = Joiner.on(newline).join(ImmutableList.of(
    "line1",
    "line2",
    "line3"));

5

का उपयोग करें Properties.loadFromXML(InputStream)। बाहरी कामों की कोई आवश्यकता नहीं है।

एक गन्दा कोड से बेहतर (चूंकि रखरखाव और डिजाइन आपकी चिंता है), यह लंबे समय तक तार का उपयोग नहीं करने के लिए बेहतर है।

Xml गुण पढ़ने से शुरू करें:

 InputStream fileIS = YourClass.class.getResourceAsStream("MultiLine.xml");
 Properties prop = new Properies();
 prop.loadFromXML(fileIS);


तब आप अपने बहुस्तरीय स्ट्रिंग को अधिक रख-रखाव वाले तरीके से उपयोग कर सकते हैं ...

static final String UNIQUE_MEANINGFUL_KEY = "Super Duper UNIQUE Key";
prop.getProperty(UNIQUE_MEANINGFUL_KEY) // "\n    MEGA\n   LONG\n..."


MultiLine.xml` एक ही फ़ोल्डर में स्थित हो जाता है YourClass:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">

<properties>
    <entry key="Super Duper UNIQUE Key">
       MEGA
       LONG
       MULTILINE
    </entry>
</properties>

पुनश्च: आप xml जैसी स्ट्रिंग के लिए <![CDATA["... का उपयोग कर सकते हैं "]]>


हाँ, यह वही है जो मैं भी उपयोग करता हूं, महान समाधान! SQL या XML को बाहरी XML संपत्ति फ़ाइल में ले जाएं। यह कोड को गड़बड़ नहीं करता है। :)
लास्ज़लो लुगोसी

इस सवाल का जवाब नहीं है। heredoc's फाइल के भीतर परिभाषा के अनुसार हैं । बिंदु यह है कि इसे एक स्थान पर रखा जाए।
जावदा

5

साथ JDK / 12 जल्दी पहुँच का निर्माण # 12 , एक अब बहु तार जावा में इस प्रकार के रूप में उपयोग कर सकते हैं:

String multiLine = `First line
    Second line with indentation
Third line
and so on...`; // the formatting as desired
System.out.println(multiLine);

और इसका परिणाम निम्न आउटपुट में होता है:

First line
    Second line with indentation
Third line
and so on...

संपादित करें: जावा 13 के लिए स्थगित



2
जैसा कि साइबर कमेंट अन्य टिप्पणी पर कहता है, कच्चे स्ट्रिंग शाब्दिक (JEP326) को अंतिम JDK12 से हटा दिया गया है, लेकिन "टेक्स्ट ब्लॉक" को जोड़ने के लिए एक और JEP बनाया गया है जो कि JDK 13 में पूर्वावलोकन के रूप में किया जा सकता है
Manueliroiro

4

एक काफी कुशल और प्लेटफ़ॉर्म स्वतंत्र समाधान स्ट्रिंग्स बनाने के लिए लाइन सेपरेटर और स्ट्रिंगबर्ल क्लास के लिए सिस्टम प्रॉपर्टी का उपयोग करेगा:

String separator = System.getProperty("line.separator");
String[] lines = {"Line 1", "Line 2" /*, ... */};

StringBuilder builder = new StringBuilder(lines[0]);
for (int i = 1; i < lines.length(); i++) {
    builder.append(separator).append(lines[i]);
}
String multiLine = builder.toString();

4

एक अच्छा विकल्प।

import static some.Util.*;

    public class Java {

        public static void main(String[] args) {

            String sql = $(
              "Select * from java",
              "join some on ",
              "group by"        
            );

            System.out.println(sql);
        }

    }


    public class Util {

        public static String $(String ...sql){
            return String.join(System.getProperty("line.separator"),sql);
        }

    }

4

यह एक बहुत ही सामान्य प्रश्न है, इसलिए मैंने इस उत्तर को एक लेख में बदलने का फैसला किया ।

जावा 13 और उसके बाद

मल्टीलाइन स्ट्रिंग्स अब टेक्स्ट ब्लॉक के माध्यम से जावा में समर्थित हैं । जावा 13 और 14 में, इस सुविधा से आपको ––enable–previewअपनी परियोजना बनाते और चलाते समय विकल्प सेट करने की आवश्यकता होती है । इस जावा प्रलेखन की जाँच करें अधिक जानकारी के लिए।

अब, जावा 13 से पहले, यह है कि आप एक प्रश्न कैसे लिखेंगे:

List<Tuple> posts = entityManager
.createNativeQuery(
    "SELECT *\n" +
    "FROM (\n" +
    "    SELECT *,\n" +
    "           dense_rank() OVER (\n" +
    "               ORDER BY \"p.created_on\", \"p.id\"\n" +
    "           ) rank\n" +
    "    FROM (\n" +
    "        SELECT p.id AS \"p.id\",\n" +
    "               p.created_on AS \"p.created_on\",\n" +
    "               p.title AS \"p.title\",\n" +
    "               pc.id as \"pc.id\",\n" +
    "               pc.created_on AS \"pc.created_on\",\n" +
    "               pc.review AS \"pc.review\",\n" +
    "               pc.post_id AS \"pc.post_id\"\n" +
    "        FROM post p\n" +
    "        LEFT JOIN post_comment pc ON p.id = pc.post_id\n" +
    "        WHERE p.title LIKE :titlePattern\n" +
    "        ORDER BY p.created_on\n" +
    "    ) p_pc\n" +
    ") p_pc_r\n" +
    "WHERE p_pc_r.rank <= :rank\n",
    Tuple.class)
.setParameter("titlePattern", "High-Performance Java Persistence %")
.setParameter("rank", 5)
.getResultList();

जावा 13 टेक्स्ट ब्लॉक के लिए धन्यवाद, आप इस प्रश्न को इस प्रकार से फिर से लिख सकते हैं:

List<Tuple> posts = entityManager
.createNativeQuery("""
    SELECT *
    FROM (
        SELECT *,
               dense_rank() OVER (
                   ORDER BY "p.created_on", "p.id"
               ) rank
        FROM (
            SELECT p.id AS "p.id",
                   p.created_on AS "p.created_on",
                   p.title AS "p.title",
                   pc.id as "pc.id",
                   pc.created_on AS "pc.created_on",
                   pc.review AS "pc.review",
                   pc.post_id AS "pc.post_id"
            FROM post p
            LEFT JOIN post_comment pc ON p.id = pc.post_id
            WHERE p.title LIKE :titlePattern
            ORDER BY p.created_on
        ) p_pc
    ) p_pc_r
    WHERE p_pc_r.rank <= :rank
    """,
    Tuple.class)
.setParameter("titlePattern", "High-Performance Java Persistence %")
.setParameter("rank", 5)
.getResultList();

बहुत अधिक पठनीय, सही?

आईडीई समर्थन

IntelliJ IDEA Stringनए बहुस्तरीय Stringप्रारूप में विरासत संगति ब्लॉकों को बदलने के लिए समर्थन प्रदान करता है :

IntelliJ IDEA टेक्स्ट ब्लॉक समर्थन करते हैं

JSON, HTML, XML

मल्टीलाइन है String विशेष रूप से उपयोगी है जब JSON, एचटीएमएल, या XML लेखन है।

StringJSON स्ट्रिंग शाब्दिक बनाने के लिए संघनन का उपयोग करके इस उदाहरण पर विचार करें :

entityManager.persist(
    new Book()
    .setId(1L)
    .setIsbn("978-9730228236")
    .setProperties(
        "{" +
        "   \"title\": \"High-Performance Java Persistence\"," +
        "   \"author\": \"Vlad Mihalcea\"," +
        "   \"publisher\": \"Amazon\"," +
        "   \"price\": 44.99," +
        "   \"reviews\": [" +
        "       {" +
        "           \"reviewer\": \"Cristiano\", " +
        "           \"review\": \"Excellent book to understand Java Persistence\", " +
        "           \"date\": \"2017-11-14\", " +
        "           \"rating\": 5" +
        "       }," +
        "       {" +
        "           \"reviewer\": \"T.W\", " +
        "           \"review\": \"The best JPA ORM book out there\", " +
        "           \"date\": \"2019-01-27\", " +
        "           \"rating\": 5" +
        "       }," +
        "       {" +
        "           \"reviewer\": \"Shaikh\", " +
        "           \"review\": \"The most informative book\", " +
        "           \"date\": \"2016-12-24\", " +
        "           \"rating\": 4" +
        "       }" +
        "   ]" +
        "}"
    )
);

भागने के पात्रों और दोहरे उद्धरण चिह्नों और प्लस संकेतों की प्रचुरता के कारण आप JSON को मुश्किल से पढ़ सकते हैं।

जावा टेक्स्ट ब्लॉक के साथ, JSON ऑब्जेक्ट को इस तरह लिखा जा सकता है:

entityManager.persist(
    new Book()
    .setId(1L)
    .setIsbn("978-9730228236")
    .setProperties("""
        {
           "title": "High-Performance Java Persistence",
           "author": "Vlad Mihalcea",
           "publisher": "Amazon",
           "price": 44.99,
           "reviews": [
               {
                   "reviewer": "Cristiano",
                   "review": "Excellent book to understand Java Persistence",
                   "date": "2017-11-14",
                   "rating": 5
               },
               {
                   "reviewer": "T.W",
                   "review": "The best JPA ORM book out there",
                   "date": "2019-01-27",
                   "rating": 5
               },
               {
                   "reviewer": "Shaikh",
                   "review": "The most informative book",
                   "date": "2016-12-24",
                   "rating": 4
               }
           ]
        }
        """
    )
);

जब से मैंने 2004 में C # का उपयोग किया था, तब से मैं जावा में इस सुविधा को प्राप्त करना चाहता था, और अब अंत में हमारे पास यह है।


3

एक गुण फ़ाइल में मेरे स्ट्रिंग को परिभाषित करें?

गुण फाइलों में मल्टीलाइन स्ट्रिंग्स की अनुमति नहीं है। आप गुण फ़ाइलों में \ n का उपयोग कर सकते हैं, लेकिन मुझे नहीं लगता कि आपके मामले में इसका कोई समाधान है।


एक गुण फ़ाइल में मान कई पंक्तियों को जोड़ सकता है: बस सभी पंक्तियों को समाप्त करें लेकिन बैकस्लैश के साथ अंतिम। यह आपके द्वारा लाइन विभाजक के रूप में उपयोग की गई समस्या को छोड़ देता है, क्योंकि यह प्लेटफ़ॉर्म-विशिष्ट है। मुझे लगता है कि आप एक साधारण \ n का उपयोग कर सकते हैं और फिर अपने कोड में, संपत्ति को पढ़ने के बाद, एक खोज-और-प्रतिस्थापित \ n से line.separator करें। यह थोड़ा कठिन लगता है, लेकिन मुझे लगता है कि आप एक फ़ंक्शन लिख सकते हैं जो एक संपत्ति को पुनः प्राप्त करता है और एक ही समय में यह हेरफेर करता है। खैर, यह मानकर कि आप इन स्ट्रिंग्स को एक फ़ाइल में लिख रहे हैं, जो एक बड़ी धारणा है।
Jay

3

मैं जानता हूं कि यह एक पुराना सवाल है, हालांकि इंटरस्ट डेवलपर्स मल्टी लाइन शाब्दिकों के लिए # जावा 12 में होना चाहिए

http://mail.openjdk.java.net/pipermail/amber-dev/2018-July/003254.html


नहीं। लेकिन था अंत में जावा 13. कौन सा मेरी टीमों की संभावना डेढ़ दशक के बारे में में ले लेता है के लिए बनाते हैं।
जावदबा

3

मैं थॉमसपी द्वारा सुझाए गए अनुसार उपयोगिता का उपयोग करने का सुझाव देता हूं, और फिर इसे अपनी निर्माण प्रक्रिया में जोड़ता हूं। पाठ को समाहित करने के लिए एक बाहरी फ़ाइल अभी भी मौजूद है, लेकिन रनटाइम पर फ़ाइल को पढ़ा नहीं जाता है। वर्कफ़्लो तब है:

  1. एक 'textfile to java code' यूटिलिटी बनाएं और वर्जन कंट्रोल में चेक करें
  2. प्रत्येक बिल्ड पर, संशोधित जावा स्रोत बनाने के लिए संसाधन फ़ाइल के विरुद्ध उपयोगिता को चलाएं
  3. जावा स्रोत में एक हेडर होता है जैसे class TextBlock {... कि एक स्टैटिक स्ट्रिंग होता है जो संसाधन फ़ाइल से स्वतः उत्पन्न होता है
  4. अपने कोड के बाकी के साथ उत्पन्न जावा फ़ाइल बनाएँ

2

जब + की एक लंबी श्रृंखला का उपयोग किया जाता है, तो केवल एक स्ट्रिंगबर्स्ट बनाया जाता है, जब तक कि स्ट्रिंग को संकलन समय पर निर्धारित नहीं किया जाता है जिस स्थिति में स्ट्रिंगब्यूलर का उपयोग नहीं किया जाता है!

जब स्ट्रिंग का निर्माण करने के लिए कई बयानों का उपयोग किया जाता है, तो एकमात्र समय StringBuilder अधिक कुशल होता है।

String a = "a\n";
String b = "b\n";
String c = "c\n";
String d = "d\n";

String abcd = a + b + c + d;
System.out.println(abcd);

String abcd2 = "a\n" +
        "b\n" +
        "c\n" +
        "d\n";
System.out.println(abcd2);

नोट: केवल एक StringBuilder बनाया गया है।

  Code:
   0:   ldc     #2; //String a\n
   2:   astore_1
   3:   ldc     #3; //String b\n
   5:   astore_2
   6:   ldc     #4; //String c\n
   8:   astore_3
   9:   ldc     #5; //String d\n
   11:  astore  4
   13:  new     #6; //class java/lang/StringBuilder
   16:  dup
   17:  invokespecial   #7; //Method java/lang/StringBuilder."<init>":()V
   20:  aload_1
   21:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   24:  aload_2
   25:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   28:  aload_3
   29:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   32:  aload   4
   34:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   37:  invokevirtual   #9; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   40:  astore  5
   42:  getstatic       #10; //Field java/lang/System.out:Ljava/io/PrintStream;
   45:  aload   5
   47:  invokevirtual   #11; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   50:  ldc     #12; //String a\nb\nc\nd\n
   52:  astore  6
   54:  getstatic       #10; //Field java/lang/System.out:Ljava/io/PrintStream;
   57:  aload   6
   59:  invokevirtual   #11; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   62:  return

अपने प्रश्न को और स्पष्ट करने के लिए, मुझे प्रदर्शन के बारे में बिल्कुल चिंता नहीं है। मैं स्थिरता और डिजाइन मुद्दों के बारे में चिंतित हूं।

जितना हो सके इसे स्पष्ट और सरल बनाएं।

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