Perl geliyor, eminim kaynak kodunda çok satırlı bir dize oluşturma "here-document" araçlarını eksik:

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

Java'da, çok satırlı dizimi sıfırdan birleştirdiğim için her satırda hantal tırnaklar ve artı işaretlerim olması gerekiyor.

Daha iyi alternatifler nelerdir? Dizgimi özellikler dosyasında tanımla?

Düzenleme : İki cevap StringBuilder.append () artı gösterimi tercih söylüyorlar. Herkes neden böyle düşündüğünü açıklayabilir mi? Benim için daha fazla tercih edilmiyor. Ben çok yollu dizeleri birinci sınıf bir dil yapısı değil aslında etrafında bir yol arıyorum, kesinlikle yöntem çağrıları ile birinci sınıf bir dil yapısı (dize birleştirme artı) yerine istemiyorum anlamına gelir.

Edit : Sorum daha açıklamak için, ben hiç performans endişe değilim. Sürdürülebilirlik ve tasarım konularından endişeliyim.

Stephen Colebourne, Java 7'de çok satırlı dizeler eklemek için bir teklif oluşturdu .

Ayrıca, Groovy zaten çok satırlı dizeleri destekliyor .

Java'da bulunmayan çok satırlı bir hazır bilgi yapmak istediğiniz gibi görünüyor.

En iyi alternatifiniz sadece bir +arada olan dizeler olacak . Kullanıcıların bahsettiği diğer bazı seçenekler (StringBuilder, String.format, String.join) yalnızca bir dizi dizeyle başlarsanız tercih edilir.

Bunu düşün:

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

Karşı 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();

Karşı 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"
);

Java8'e karşı 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"
);

Eğer kullanımına, ya gerek belli bir sistem için yeni satır istiyorsanız System.lineSeparator()veya kullanabilir %niçinde String.format.

Başka bir seçenek, kaynağı bir metin dosyasına koymak ve sadece dosyanın içeriğini okumaktır. Bu, sınıf dosyalarınızı gereksiz yere şişirmemek için çok büyük dizeler için tercih edilir.

Eclipse'de "Bir dize hazır bilgisine yapıştırırken metinden kaç" seçeneğini açarsanız (Tercihler> Java> Editör> Yazma) ve tırnak işaretleri arasına çok çizgili bir dize yapıştırırsanız, otomatik olarak " ve \n" +tüm satırlarınız için .

String str = "paste your text here";

Bu eski bir iş parçacığıdır, ancak yeni bir zarif çözüm (sadece 4 belki 3 küçük dezavantajı olan) özel bir ek açıklama kullanmaktır.

Kontrol edin: http://www.adrianwalker.org/2011/12/java-multiline-string.html

Bu çalışmadan esinlenen bir proje GitHub'da barındırılıyor:

https://github.com/benelog/multiline

Java kodu örneği:

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

Dezavantajları

1. karşılık gelen (sağlanan) ek açıklama işlemcisini etkinleştirmeniz gerekir.
2. Dize değişkeni yerel değişken olarak tanımlanamıyor Ham Dize Değişmezlerini Denetle projesi değişken olarak tanımlanamıyor Değişkenleri yerel değişkenler olarak tanımlayabileceğiniz
3. Bu String XML değişmezine sahip Visual Basic .Net'teki diğer değişkenleri içeremez<%= variable %> ) :-) içeremez
4. Dize değişmezinin JavaDoc yorumu tarafından sınırlandırıldığı (/ **)

Ve muhtemelen Eclipse / Intellij-Idea'yı Javadoc yorumlarınızı otomatik olarak yeniden biçimlendirmeyecek şekilde yapılandırmanız gerekir.

Biri bu garip bulabilir (Javadoc yorumları yorumlardan başka bir şey gömmek için tasarlanmamıştır), ancak Java'daki çok satırlı dize eksikliği sonunda gerçekten can sıkıcı olduğundan, bunu en kötü çözüm olarak görüyorum.

Başka bir seçenek, uzun dizeleri harici bir dosyada saklamak ve dosyayı bir dizeye okumak olabilir.

Bu, ne yaptığını düşünmeden asla kullanmamanız gereken bir şey . Ancak bir kerelik komut dosyaları için bunu büyük bir başarıyla kullandım:

Misal:

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

Kod:

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

String.join

Java 8 java.lang.String, biraz daha iyi bir alternatif sunan yeni bir statik yöntem ekledi :

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

Kullanma:

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

JEP 355: Metin Blokları (Önizleme) bu işlevselliği kapsamayı amaçlamaktadır, şu anda JDK 13'ü bir önizleme özelliği olarak hedeflemektedir . Şunun gibi bir şey yazmaya izin vermek:

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

Bu JEP'ten önce, JDK12'de, JEP 326: Raw String Literals benzer bir özellik uygulamayı amaçladı, ancak sonunda geri çekildi.

Dizelerinizi bir özellikler dosyasında tanımlarsanız çok daha kötü görünür. IIRC, şöyle görünecektir:

string:text\u000atext\u000atext\u000a

Genelde büyük dizeleri kaynağa yerleştirmemek makul bir fikirdir. Bunları kaynak olarak, belki XML veya okunabilir bir metin biçiminde yüklemek isteyebilirsiniz. Metin dosyaları çalışma zamanında okunabilir veya Java kaynağında derlenebilir. Eğer onları kaynağa yerleştirirseniz +, ön tarafa koymanızı ve gereksiz yeni satırları atlamayı öneririm :

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

Yeni satırlarınız varsa, birleştirme veya biçimlendirme yönteminden bazılarını isteyebilirsiniz:

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

Artılar, her iki dizenin de sabit olması dışında derleyicinin bunları derleme zamanında birleştirebilmesi dışında StringBuilder.append biçimine dönüştürülür. En azından, Sun'ın derleyicisinde böyle ve diğer tüm derleyiciler de aynısını yapmasa bile çoğundan şüphelenirim.

Yani:

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

normalde tam olarak aynı kodu üretir:

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

Diğer yandan:

String c="Hello"+"Goodbye";

aynıdır:

String c="HelloGoodbye";

Yani, dize değişmezlerinizi birden fazla satır boyunca okunabilirlik için artı işaretleriyle kırmanın herhangi bir cezası yoktur.

IntelliJ IDE'de şunları yazmanız gerekir:

""

Ardından imlecinizi tırnak işaretleri içine alın ve dizenizi yapıştırın. IDE bunu birden çok birleştirilmiş satıra genişletir.

Ne yazık ki Java'nın çok satırlı dize değişmez değerleri yok. Dize değişmezlerini birleştirmelisiniz (+ veya StringBuilder kullanarak bunun en yaygın iki yaklaşımıdır) veya dizeyi ayrı bir dosyadan okumalısınız.

Büyük çok satırlı dize değişmezleri için, ayrı bir dosya kullanmaya ve bunu kullanırken okumaya meyilli olurum getResourceAsStream() (Class sınıfın . Bu, kodun kurulu olduğu yere karşı geçerli dizin hakkında endişelenmenize gerek olmadığından dosyayı bulmanızı kolaylaştırır. Aynı zamanda ambalajı da kolaylaştırır, çünkü dosyayı jar dosyanızda saklayabilirsiniz.

Diyelim ki Foo adında bir sınıftasınız. Sadece böyle bir şey yapın:

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

Diğer bir sıkıntı, Java'nın standart bir "bu Reader'daki metnin tamamını bir String'e oku" yöntemine sahip olmamasıdır. Yine de yazmak oldukça kolay:

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

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

Ancak, en iyi alternatif String.format kullanmaktır

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

Java çok satırlı dizeleri yerel olarak desteklemediğinden (şimdilik), şimdilik tek yol, yukarıda belirtilen tekniklerden birini kullanarak onu kesmek. Yukarıda belirtilen püf noktaları kullanarak aşağıdaki Python betiğini oluşturdum:

import sys
import string
import os

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

Bunu javastringify.py adlı bir dosyaya ve dizenizi mystring.txt dosyasına koyun ve aşağıdaki gibi çalıştırın:

cat mystring.txt | python javastringify.py

Daha sonra çıktıyı kopyalayıp düzenleyicinize yapıştırabilirsiniz.

Herhangi bir özel durumla başa çıkmak için bunu gerektiği gibi değiştirin, ancak bu benim ihtiyaçlarım için işe yarıyor. Bu yardımcı olur umarım!

Java ile uyumlu olan ve "" "ile çevrili çok satırlı Dizelere izin veren scala kodunu kullanabilirsiniz:

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

(dizenin içindeki tırnaklara dikkat edin) ve java:

String s2 = foobar.SWrap.bar ();

Bunun daha rahat olup olmadığı ...?

Kaynak kodunuza yerleştirilmesi gereken uzun metinleri sık sık ele alıyorsanız, başka bir yaklaşım, metni harici bir dosyadan alan ve böyle bir çok satırlı java-String olarak saran bir komut dosyası olabilir:

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

böylece kaynağınıza kolayca kesip yapıştırabilirsiniz.

Eklerinizi aşağıdaki gibi ayrı bir yöntemle birleştirebilirsiniz:

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

Her iki durumda StringBuilderda, artı gösterimi tercih edin.

Aslında, şu ana kadar gördüğüm en temiz uygulama. Bir açıklamayı dize değişkenine dönüştürmek için bir ek açıklama kullanır ...

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

Sonuç olarak, html değişkeni çok satırlı dizeyi içerir. Tırnak yok, artı yok, virgül yok, sadece saf dize.

Bu çözüme aşağıdaki URL'den ulaşabilirsiniz ... http://www.adrianwalker.org/2011/12/java-multiline-string.html

Umarım yardımcı olur!

Bkz. Java Stringfier . Metninizi gerekirse bir StringBuilder java bloğuna dönüştürür.

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

Henüz cevap olarak görmediğim bir alternatif 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();

Ayrıca java.io.BufferedWriterbir newLine()yönteme sahip olduğu gerçeği de belirtilmemiş.

Google'ın guava'sını benim kadar beğendiyseniz, oldukça temiz bir temsil ve yeni satır karakterlerinizi de kodlamamak için güzel ve kolay bir yol sağlayabilir:

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

kullanım Properties.loadFromXML(InputStream) . Dış kütüphanelere ihtiyaç yoktur.

Dağınık bir koddan daha iyi (sürdürülebilirlik ve tasarım endişeniz olduğundan) uzun dizeler kullanmamanız tercih edilir.

Xml özelliklerini okuyarak başlayın:

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

çok satırlı dizenizi daha sürdürülebilir bir şekilde kullanabilirsiniz ...

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

MultiLine.xml` aynı klasörde bulunur

<?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>

Not: xml benzeri dize için <![CDATA["... kullanabilirsiniz "]]>.

İle JDK / 12 erken erişim yapı # 12 aşağıdaki gibi, bir anda Java satırlı dizeleri kullanabilirsiniz:

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

ve bu aşağıdaki çıktı ile sonuçlanır:

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

Düzenleme: Java 13'e ertelendi

Oldukça verimli ve platformdan bağımsız bir çözüm, satır ayırıcılar için system özelliğini ve dizeleri oluşturmak için StringBuilder sınıfını kullanmak olacaktır:

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

İyi bir seçenek.

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

    }

Bu çok yaygın bir soru, bu yüzden bu yanıtı bir makaleye dönüştürmeye karar verdim .

Java 13 ve sonrası

Çok Satırlı Dizeler artık Metin Blokları aracılığıyla Java'da desteklenmektedir . Java 13 ve 14'te, bu özellik ––enable–previewprojenizi oluştururken ve çalıştırırken seçeneği belirlemenizi gerektirir . Bu Java belgelerine göz atın fazla ayrıntı için.

Java 13'ten önce, şu şekilde bir sorgu yazarsınız:

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

Java 13 Metin Blokları sayesinde, bu sorguyu aşağıdaki gibi yeniden yazabilirsiniz:

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

Çok daha okunabilir değil mi?

IDE desteği

IntelliJ IDEA, eski Stringbirleştirme bloklarını yeni çok satırlı Stringformata dönüştürmek için destek sağlar :

JSON, HTML, XML

Çok satırlı String özellikle JSON, HTML veya XML yazarken kullanışlıdır.

StringJSON dizgi değişmezi oluşturmak için birleştirme kullanarak bu örneği düşünün :

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

Kaçan karakterler ve çift tırnak ve artı işaretlerinin bolluğu nedeniyle JSON'u zar zor okuyabilirsiniz.

Java Metin Blokları ile JSON nesnesi şu şekilde yazılabilir:

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'te C # kullandığımdan beri, Java'da bu özelliğe sahip olmak istiyordum ve şimdi de sahip olduk.

Dizem bir özellikler dosyasında tanımlansın mı?

Özellikler dosyalarında çok satırlı dizelere izin verilmez. Özellikler dosyalarında \ n kullanabilirsiniz, ancak durumunuzda bunun bir çözüm olduğunu düşünmüyorum.

Bunun eski bir soru olduğunu biliyorum, ancak intersted geliştiriciler için # line12

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

ThomasP tarafından önerilen bir yardımcı program kullanmanızı ve ardından bunu oluşturma işleminize bağlamanızı öneririm. Metni içerecek harici bir dosya hala var, ancak dosya çalışma zamanında okunmuyor. Bu durumda iş akışı:

1. Bir 'java koduna textfile' yardımcı programı oluşturun ve sürüm kontrolüne bakın
2. Her derlemede, düzeltilmiş bir java kaynağı oluşturmak için yardımcı programı kaynak dosyasına karşı çalıştırın
3. Java kaynağı aşağıdaki gibi bir başlık içerir class TextBlock {... , kaynak dosyadan otomatik olarak oluşturulan statik bir dize
4. Kodunuzun geri kalanıyla oluşturulan java dosyasını oluşturun

Uzun bir + serisi kullanıldığında, String derleme zamanında belirlenmediği sürece yalnızca bir StringBuilder oluşturulur; bu durumda hiçbir StringBuilder kullanılmaz!

StringBuilder'ın daha verimli olduğu tek zaman, String'i oluşturmak için birden fazla ifade kullanılmasıdır.

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

Not: Yalnızca bir StringBuilder oluşturulur.

  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

Sorumu daha da netleştirmek için performanstan hiç endişe duymuyorum. Sürdürülebilirlik ve tasarım konularından endişeliyim.

Olabildiğince açık ve basit hale getirin.