it-swarm.com.de

Java mehrzeilige Zeichenfolge

Aus Perl kommend, fehlt mir das "Here-Document" -Mittel zum Erstellen einer mehrzeiligen Zeichenfolge im Quellcode:

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

In Java muss ich in jeder Zeile umständliche Anführungszeichen und Pluszeichen verwenden, wenn ich meine mehrzeilige Zeichenfolge von Grund auf verketten.

Was gibt es bessere Alternativen? Definieren Sie meine Zeichenfolge in einer Eigenschaftendatei.

Edit : Zwei Antworten sagen, dass StringBuilder.append () der Plus-Notation vorzuziehen ist. Könnte jemand etwas näher erläutern, warum sie so denken? Es sieht mir überhaupt nicht vorzuziehen. Ich bin auf der Suche nach einem Weg, die Tatsache zu umgehen, dass mehrzeilige Zeichenfolgen kein erstklassiges Sprachkonstrukt sind. Das heißt, ich möchte auf keinen Fall ein erstklassiges Sprachkonstrukt (String-Verkettung mit Plus) durch Methodenaufrufe ersetzen.

Edit : Um meine Frage weiter zu klären, mache ich mir überhaupt keine Gedanken um die Leistung. Ich mache mir Sorgen über Wartbarkeit und Designprobleme.

439
skiphoppy

Stephen Colebourne hat einen Vorschlag zum Hinzufügen von mehrzeiligen Zeichenfolgen in Java 7 erstellt.

Groovy unterstützt auch bereits mehrzeilige Zeichenfolgen .

106
Paul Morie

Es klingt, als würden Sie ein mehrzeiliges Literal verwenden, das in Java nicht vorhanden ist.

Die beste Alternative sind Strings, die nur aus + zusammen bestehen. Einige andere Optionen, die die Leute erwähnt haben (StringBuilder, String.format, String.join), sind nur vorzuziehen, wenn Sie mit einem String-Array begonnen haben.

Bedenken Sie:

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

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

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

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

Wenn Sie die Newline für Ihr spezielles System wünschen, müssen Sie entweder System.getProperty("line.separator") verwenden oder %n in String.format.

Eine andere Möglichkeit besteht darin, die Ressource in eine Textdatei zu legen und nur den Inhalt dieser Datei zu lesen. Dies ist für sehr große Zeichenfolgen vorzuziehen, um eine unnötige Aufblähung Ihrer Klassendateien zu vermeiden.

425
Kip

Wenn Sie in Eclipse die Option "Text beim Einfügen in ein Textliteral einfügen" aktivieren (in Voreinstellungen> Java> Editor> Typisierung) und eine mehrzeilige Zeichenfolge in Anführungszeichen einfügen, werden automatisch " und \n" + für alle Zeilen hinzugefügt.

String str = "paste your text here";
183
Monir

Dies ist ein alter Thread, aber eine neue, recht elegante Lösung (mit nur 4 vielleicht 3 kleinen Nachteilen) ist die Verwendung einer benutzerdefinierten Annotation.

Check: http://www.adrianwalker.org/2011/12/Java-multiline-string.html

Ein von dieser Arbeit inspiriertes Projekt wird auf GitHub gehostet: 

https://github.com/benelog/multiline

Beispiel für Java-Code:

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

Die Nachteile sind 

  1. dass Sie die entsprechende (bereitgestellte) Anmerkung Prozessor aktivieren müssen. 
  2. diese String-Variable kann nicht als lokale Variable definiert werden. Check Raw String Literals project , in der Sie Variablen als lokale Variablen definieren können 
  3. dieser String darf keine anderen Variablen enthalten wie in Visual Basic .Net mit XML-Literal (<%= variable %>) :-)
  4. dieses String-Literal wird durch einen JavaDoc-Kommentar (/ **) begrenzt.

Wahrscheinlich müssen Sie Eclipse/Intellij-Idea so konfigurieren, dass Ihre Javadoc-Kommentare nicht automatisch formatiert werden.

Man könnte das seltsam finden (Javadoc-Kommentare sind nicht dazu gedacht, etwas anderes als Kommentare einzubetten), aber da das Fehlen von Multiline-Strings in Java am Ende wirklich ärgerlich ist, finde ich, dass dies die am wenigsten schlechte Lösung ist.

91
SRG

Eine andere Option kann sein, lange Zeichenfolgen in einer externen Datei zu speichern und die Datei in eine Zeichenfolge zu lesen.

57
Josh Curren

Dies ist etwas, das Sie nie verwenden sollten, ohne darüber nachzudenken, was es tut. Aber für einmalige Skripte habe ich dies mit großem Erfolg verwendet:

Beispiel:

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

Code:

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

String.join

Java 8 fügte Java.lang.String eine neue statische Methode hinzu, die eine etwas bessere Alternative bietet:

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

Es benutzen:

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

Wenn Sie Ihre Zeichenfolgen in einer Eigenschaftendatei definieren, sieht das wesentlich schlechter aus. IIRC, es sieht so aus:

string:text\u000atext\u000atext\u000a

Im Allgemeinen ist es eine sinnvolle Idee, keine großen Zeichenfolgen in die Quelle einzubetten. Möglicherweise möchten Sie sie als Ressourcen laden, z. B. in XML oder in einem lesbaren Textformat. Die Textdateien können entweder zur Laufzeit gelesen oder in eine Java-Quelle kompiliert werden. Wenn Sie sie am Ende in der Quelle platzieren, schlage ich vor, den + an die Vorderseite zu setzen und unnötige neue Zeilen wegzulassen:

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

Wenn Sie neue Zeilen haben, möchten Sie vielleicht eine Join- oder Formatierungsmethode:

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

Pluszeichen werden in StringBuilder.append konvertiert, außer wenn beide Zeichenfolgen Konstanten sind, damit der Compiler sie beim Kompilieren kombinieren kann. Zumindest ist es in Suns Compiler so, und ich würde die meisten vermuten, wenn nicht alle anderen Compiler dasselbe tun würden.

So:

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

erzeugt normalerweise genau den gleichen Code wie:

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

Auf der anderen Seite:

String c="Hello"+"Goodbye";

ist das gleiche wie:

String c="HelloGoodbye";

Das heißt, es gibt keine Strafe, wenn Sie Ihre String-Literale über mehrere Zeilen mit Pluszeichen für die Lesbarkeit brechen.

17
Jay

In der IntelliJ IDE müssen Sie nur Folgendes eingeben:

""

Positionieren Sie dann den Cursor innerhalb der Anführungszeichen und fügen Sie die Zeichenfolge ein. Die IDE erweitert sie in mehrere verkettete Zeilen.

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

Die beste Alternative ist jedoch die Verwendung von String.format

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

Leider verfügt Java nicht über mehrzeilige String-Literale. Sie müssen entweder String-Literale verketten (mit + oder StringBuilder als den zwei häufigsten Ansätzen dazu) oder den String aus einer separaten Datei einlesen.

Bei großen mehrzeiligen String-Literalen neige ich dazu, eine separate Datei zu verwenden und sie mit getResourceAsStream() (einer Methode der Klasse Class) einzulesen. Auf diese Weise können Sie die Datei leicht finden, da Sie sich nicht um das aktuelle Verzeichnis kümmern müssen und nicht, wo Ihr Code installiert wurde. Dies erleichtert auch das Packen, da Sie die Datei tatsächlich in Ihrer JAR-Datei speichern können.

Angenommen, Sie sind in einer Klasse namens Foo. Mach einfach so etwas:

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

Ein weiterer Ärger ist, dass Java keinen Standard "Lesen Sie den gesamten Text aus diesem Reader in eine Zeichenfolge" -Methode. Es ist ziemlich einfach zu schreiben:

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

Sie können scala-code verwenden, der mit Java kompatibel ist und mehrzeilige Zeichenfolgen erlaubt, die in "" "eingeschlossen sind:

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

(Beachten Sie die Anführungszeichen in der Zeichenfolge) und von Java:

String s2 = foobar.SWrap.bar ();

Ob das bequemer ist ...? 

Wenn Sie häufig langen Text behandeln, der in Ihrem Quellcode enthalten sein sollte, könnte es sich um ein Skript handeln, das den Text aus einer externen Datei entnimmt und als mehrzeiligen Java-String wie folgt umgibt: 

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

damit Sie es leicht ausschneiden und in Ihre Quelle einfügen können.

9
user unknown

Da Java (noch) nativ keine mehrzeiligen Zeichenfolgen unterstützt, besteht der einzige Weg im Moment darin, es mit einer der oben genannten Techniken zu hacken. Ich habe das folgende Python-Skript mit einigen der oben genannten Tricks erstellt:

import sys
import string
import os

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

Fügen Sie das in eine Datei namens javastringify.py und Ihren String in eine Datei mystring.txt ein und führen Sie es wie folgt aus:

cat mystring.txt | python javastringify.py

Sie können die Ausgabe dann kopieren und in Ihren Editor einfügen. 

Ändern Sie dies nach Bedarf, um Sonderfälle zu behandeln, aber dies funktioniert für meine Bedürfnisse. Hoffe das hilft!

9
scorpiodawg

JEP 326: Raw String Literals wird mehrzeilige Strings implementieren, sodass Sie in der Lage sind, Folgendes zu schreiben:

String s = `
    text
    text
    text
  `;
8
alostale

Sie können Ihre Anhänge in einer separaten Methode verketten:

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

Ziehen Sie auf jeden Fall StringBuilder der Plus-Notation vor.

7
user54579

Tatsächlich ist das Folgende die sauberste Implementierung, die ich bisher gesehen habe. Es verwendet eine Annotation, um einen Kommentar in eine String-Variable zu konvertieren ...

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

Das Endergebnis ist also, dass die Variable html die mehrzeilige Zeichenfolge enthält. Keine Anführungszeichen, keine Pluspunkte, keine Kommas, nur reine Zeichenfolge.

Diese Lösung steht unter folgender URL zur Verfügung ... http://www.adrianwalker.org/2011/12/Java-multiline-string.html

Hoffentlich hilft das!

7

Siehe Java Stringfier . Verwandelt Ihren Text in einen StringBuilder-Java-Block, der bei Bedarf escape ist.

6
Leo

Eine Alternative, die ich noch nicht als Antwort gesehen habe, ist der 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();

Die Tatsache, dass Java.io.BufferedWriter eine newLine()-Methode hat, wird nicht erwähnt.

6
BalusC
    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

Wenn Sie die Guava von Google genauso mögen wie ich, kann dies eine ziemlich saubere Darstellung und eine nette, einfache Möglichkeit bieten, Ihre Zeilenumbrüche nicht zu hart zu kodieren:

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

Eine recht effiziente und plattformunabhängige Lösung würde die Systemeigenschaft für Zeilentrennzeichen und die StringBuilder-Klasse zum Erstellen von Zeichenfolgen verwenden:

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
Andreas_D

Definieren Sie meine Zeichenfolge in einer Eigenschaftendatei.

Mehrzeilige Zeichenfolgen sind in Eigenschaftendateien nicht zulässig. Sie können\n in Eigenschaftsdateien verwenden, aber ich glaube nicht, dass dies in Ihrem Fall eine Lösung ist.

3
Kip

Verwenden Sie Properties.loadFromXML(InputStream). Es gibt keine Notwendigkeit für externe Bibliotheken.

Besser als ein unordentlicher Code (da Wartbarkeit und Design für Sie von Belang sind), sollten Sie keine langen Zeichenfolgen verwenden.

Beginnen Sie mit dem Lesen der XML-Eigenschaften:

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


dann können Sie Ihre mehrzeilige Zeichenkette auf mehr pflegbare Weise verwenden ...

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


MultiLine.xml` befindet sich im selben Ordner wie 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>

PS .: Sie können <![CDATA[" ... "]]> für eine XML-ähnliche Zeichenfolge verwenden.

3
jpfreire

Eine gute Option.

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

    }
3
Bruno Marinho

Wenn eine lange Reihe von + verwendet wird, wird nur ein StringBuilder erstellt, es sei denn, der String wird zur Kompilierzeit bestimmt. In diesem Fall wird kein StringBuilder verwendet!

StringBuilder ist nur dann effizienter, wenn mehrere Anweisungen zum Erstellen des Strings verwendet werden.

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

Hinweis: Es wird nur ein StringBuilder erstellt.

  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

Um meine Frage weiter zu klären, mache ich mir überhaupt keine Gedanken um die Leistung. Ich mache mir Sorgen über Wartbarkeit und Designprobleme.

Machen Sie es so klar und einfach wie möglich.

2
Peter Lawrey

Ich schlage vor, ein von ThomasP empfohlenes Dienstprogramm zu verwenden und dieses dann mit Ihrem Build-Prozess zu verknüpfen. Es ist noch eine externe Datei vorhanden, die den Text enthalten soll, aber zur Laufzeit wird die Datei nicht gelesen. __ Der Workflow lautet dann:

  1. Erstellen Sie ein "Textfile to Java Code" -Dienstprogramm und überprüfen Sie die Versionskontrolle
  2. Führen Sie bei jedem Build das Dienstprogramm für die Ressourcendatei aus, um eine überarbeitete Java-Quelle zu erstellen
  3. Die Java-Quelle enthält einen Header wie class TextBlock {..., gefolgt von einer statischen Zeichenfolge, die automatisch aus der Ressourcendatei generiert wird
  4. Erstellen Sie die generierte Java-Datei mit dem restlichen Code
2
horace

Das späte Java-Modell verfügt über Optimierungen für + mit konstanten Zeichenfolgen und verwendet einen StringBuffer im Hintergrund, so dass Sie Ihren Code nicht damit überladen möchten.

Es weist auf ein Java-Versehen hin, dass es ANSI C bei der automatischen Verkettung von doppelten Anführungszeichenfolgen nur mit Leerzeichen zwischen den Zeilen ähnelt, z. B .:

const char usage = "\n"
"Usage: xxxx <options>\n"
"\n"
"Removes your options as designated by the required parameter <options>,\n"
"which must be one of the following strings:\n"
"  love\n"
"  sex\n"
"  drugs\n"
"  rockandroll\n"
"\n" ;

Ich hätte gerne ein mehrzeiliges Zeichenfeld, in dem eingebettete Zeilenvorschübe berücksichtigt werden, so dass ich den Block ohne Unordnung präsentieren kann, z. B .:

String Query = "
SELECT
    some_column,
    another column
  FROM
      one_table a
    JOIN
      another_table b
    ON    a.id = b.id
      AND a.role_code = b.role_code
  WHERE a.dept = 'sales'
    AND b.sales_quote > 1000
  Order BY 1, 2
" ;

Um dies zu bekommen, muss man die Java-Götter schlagen.

2
David Pickett

Ein kleiner Trick. Damit füge ich Javascript in eine dynamisch erstellte HTML-Seite ein 

StringBuilder builder = new StringBuilder();

public String getString()
{
    return builder.toString();
}
private DropdownContent _(String a)
{
    builder.append(a);
    return this;
}

public String funct_showhide()
{
   return
    _("function slidedown_showHide(boxId)").
    _("{").
    _("if(!slidedown_direction[boxId])slidedown_direction[boxId] = 1;").
    _("if(!slideDownInitHeight[boxId])slideDownInitHeight[boxId] = 0;").
    _("if(slideDownInitHeight[boxId]==0)slidedown_direction[boxId]=slidedownSpeed; ").
    _("else slidedown_direction[boxId] = slidedownSpeed*-1;").
    _("slidedownContentBox = document.getElementById(boxId);").
    _("var subDivs = slidedownContentBox.getElementsByTagName('DIV');").
    _("for(var no=0;no<subDivs.length;no++){").
    _(" if(subDivs[no].className=='dhtmlgoodies_content')slidedownContent = subDivs[no];").
    _("}").
    _("contentHeight = slidedownContent.offsetHeight;").
    _("slidedownContentBox.style.visibility='visible';").
    _("slidedownActive = true;").
    _("slidedown_showHide_start(slidedownContentBox,slidedownContent);").
    _("}").getString();

}
2
Hector Caicedo

Ich weiß, das ist eine alte Frage, aber für intersted-Entwickler werden Multi-Line-Literale in # Java12 sein

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

2
Morteza Adi

Ich benutze manchmal eine parallele groovige Klasse, nur um als Saitentasche zu fungieren

Die Java-Klasse hier

public class Test {
    public static void main(String[] args) {
        System.out.println(TestStrings.json1);
        // consume .. parse json
    }
}

Und die begehrten mehrzeiligen Saiten hier in TestStrings.groovy

class TestStrings {
    public static String json1 = """
    {
        "name": "Fakeer's Json",
        "age":100,
        "messages":["msg 1","msg 2","msg 3"]
    }""";
}

Dies gilt natürlich nur für statische Zeichenfolgen. Wenn ich Variablen in den Text einfügen muss, werde ich einfach die gesamte Datei in groovig ändern. Behalten Sie einfach starke Schreibpraktiken bei und es kann abgezogen werden.

1
Fakeer

Ich sehe mindestens einen Fall, in dem die Verwendung externer Dateien für lange Zeichenfolgen vermieden werden sollte: Wenn diese langen Zeichenfolgen erwartete Werte in einer Unit-Test-Datei sind, weil ich denke, dass die Tests immer so geschrieben werden sollten, dass sie dies nicht tun verlassen Sie sich auf eine externe Ressource.

1
Deltaplan

Mit JDK/12 Early Access Build # 12 können nun mehrzeilige Zeichenfolgen in Java wie folgt verwendet werden:

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

und dies führt zu folgender Ausgabe:

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

Es mag ein bisschen verrückt erscheinen, aber da Heredocs syntaktischen Zucker über einzeilige Deklarationen haben, bei denen Zeilenumbrüche entkommen sind, könnte man einen Vorprozessor für Java-Dateien schreiben, die Heredocs während der Vorverarbeitung in Einzeiler umwandeln. 

Sie müssen vor der Kompilierungsphase (für Ant/Maven-Build) geeignete Plugins für die Vorverarbeitung von Dateien und ein Plugin für IDE schreiben. 

Aus ideologischer Sicht unterscheidet es sich nicht von z. "Generika", das ist auch eine Art vorverarbeiteter syntaktischer Zucker über dem Guss.

Es ist jedoch eine Menge Arbeit, daher würde ich an Ihrer Stelle einfach .properties-Dateien verwenden.

1
Danubian Sailor

Verwendung dieser Bibliothek

https://github.com/alessio-santacroce/multiline-string-literals

es ist möglich, solche Dinge zu schreiben

System.out.println(newString(/*
      Wow, we finally have
      multiline strings in
      Java! HOOO!
*/));

Sehr schön und einfach, funktioniert aber nur für Komponententests

0
Peter Szanto

Ich habe mich etwas geärgert, weil ich gelesen habe, dass für jdk7 tatsächlich eine mehrzeilige Syntax geplant ist (nach etwa wie vielen Jahrzehnten Java-Existenz?). Komischerweise gibt es noch nicht einmal eine readAll () - Funktion zum Lesen des vollständigen Inhalts einer Datei (nur von jdk7, huhh), daher liest der folgende Code einzelne Zeilen. 

/* 
 MakeMultiline v1.0 (2010) - Kostenlos zu verwenden und zu kopieren .

 Kleines Gadget zum Verwandeln von Textblobs in ein Java-String-Literal 
 (Durchtrennen in Zeilen, Hinzufügen von\n an jedem Ende und Einschließen von .__ in Anführungszeichen). Gibt es Escape-Anführungszeichen im Text-Blob .

 Nützlich zum Umgehen der fehlenden mehrzeiligen Zeichenfolgensyntax in Java 
 vor jdk7. Benutzen mit:

 Java MakeMultiline "" 
 oder
 Java MakeMultiline "" mytextfile.txt 
 */

 Import Java.io. *; 

 Klasse MakeMultiline {
 public static void main (String [] args) {
 Versuchen {
 // args [0]: Einzug 
 // args [1]: zu lesender Dateiname (optional; stdin, falls nicht angegeben) 
 // Vorsicht bei der Verwendung von stdin! 

 String indent = (args.length> 0? Args [0]: ""); 
 FileReader fr = null; BufferedReader br; 
 if (args.length> 1) 
 {fr = new FileReader (args [1]); br = new BufferedReader (fr); } 
 sonst
 {br = new BufferedReader (neuer InputStreamReader (System.in)); } 
 String s; String res = ""; 
 while ((s = br.readLine ())! = null) {
 if (res.length ()> 0) res + = "+\n"; 
 res + = Einzug + "\" "+ s.replace ("\"", "\\\" ") +" \\ n\""; 
 } 
 br.close (); if (fr! = null) fr.close (); 
 System.out.println (res + ";"); 
 } 
 catch (Ausnahme e) {
 System.out.println ("Ausnahme:" + e); 
 } 
 } 
} 

Dies war die schnellste Lösung für mich. (27.01.2010)

0
ThomasP

Eine einfache Option besteht darin, Ihren Java-Code mit einem Editor wie SciTE ( http://www.scintilla.org/SciTEDownload.html ) zu bearbeiten, mit dem Sie den Text WRAP so bearbeiten können, dass lange Zeichenfolgen einfach angezeigt werden bearbeitet Wenn Sie Escape-Zeichen benötigen, fügen Sie sie einfach ein. Wenn Sie die Wrap-Option ausschalten, können Sie überprüfen, ob Ihre Zeichenfolge tatsächlich nur eine lange einzeilige Zeichenfolge ist. Natürlich sagt Ihnen der Compiler auch, wenn dies nicht der Fall ist.

Ob Eclipse oder NetBeans Textumbrüche in einem Editor unterstützen, weiß ich nicht, weil sie so viele Optionen haben. Wenn nicht, wäre das eine gute Sache. 

0
Panu Viljamaa

Ich kenne nur die Möglichkeit, mehrere Zeilen mit Pluszeichen zu verknüpfen

0
Josh Curren