Text Blocks richtig verwenden

Java Tutorial: Eine Einführung in Text Blocks und offizieller Style Guide

Jim Laskey, Stuart Marks

© Shutterstock / olgers (modifiziert)

JEP 355 führte Text Blocks als Preview Feature in Java SE 13 ein. Während das JEP dieses neue Feature sehr detailliert erklärt, ist nicht immer klar, wie das Feature verwendet werden kann. Aus diesem Grund enthält dieser offizielle Guide von Oracle einige praktische Anwendungshinweise und Richtlinien für die Text-Block-Funktion.

Text Blocks in Java: Eine Einführung

Die Hauptfunktion eines Text Blocks ist es, übersichtliche Strukturen zu schaffen. Dafür minimiert er die sich über mehrere Zeilen erstreckende Java-Syntax, die erforderlich ist, um einen String zu rendern.

In früheren Versionen des JDKs erforderte die Einbettung von mehrzeiligen Code Snippets ein Durcheinander von expliziten Zeilenabschlüssen, String-Verknüpfungen und Trennzeichen. Text Blocks beseitigen die meisten dieser Hürden und ermöglichen es, Code Snippets und Textsequenzen mehr oder weniger wie bisher einzubetten.

Ein Text Block ist eine alternative Form der String-Darstellung in Java, die überall dort eingesetzt werden kann, wo ein herkömmliches, doppeltes String-Literal verwendet wird. Zum Beispiel:

// Using a literal string
String dqName = "Pat Q. Smith";

// Using a text block
String tbName = """
                Pat Q. Smith""";

Das Objekt, das aus einem Text Block erzeugt wird, ist ein java.lang.String mit den gleichen Eigenschaften wie ein herkömmlicher String zwischen zwei Anführungszeichen. Dazu gehört sowohl die Darstellung als auch das Interning von Objekten. Fahren wir mit dqName und tbName aus den obigen Beispielen fort:

// Sowohl dqName als auch tbName sind Strings mit gleichem Wert
dqName.equals(tbName)    // true

// Sowohl dqName als auch tbName werden durch Interning zum selben String 
dqName == tbName         // true

Text Blocks können überall dort verwendet werden, wo ein String-Literal verwendet wird. Beispielsweise können Text Blocks mit String-Literalen in einem Ausdruck zur String-Verdichtung vermischt werden:

String str = "The old";
String tb = """
            the new""";
String together = str + " and " + tb + ".";

Text Blocks können als Methodenargument verwendet werden:

System.out.println("""
    This is the first line
    This is the second line
    This is the third line
    """);

String-Methoden können auf einen Text Block angewendet werden:

"""
John Q. Smith""".substring(8).equals("Smith")    // true

Ein Text Block kann anstelle eines String-Literals verwendet werden, um die Lesbarkeit und Übersichtlichkeit des Codes zu verbessern. Dies tritt vor allem auf, wenn ein String-Literal verwendet wird, um einen mehrzeiligen String darzustellen. In diesem Fall gibt es eine unübersichtliche Häufung von Anführungszeichen, Zeilenumbrüchen und Verkettungsoperatoren:

// ORIGINAL
String message = "'The time has come,' the Walrus said,\n" +
                 "'To talk of many things:\n" +
                 "Of shoes -- and ships -- and sealing-wax --\n" +
                 "Of cabbages -- and kings --\n" +
                 "And why the sea is boiling hot --\n" +
                 "And whether pigs have wings.'\n";

Die Verwendung von Text Blocks beseitigt einen Großteil der Unordnung:

// BETTER
String message = """
    'The time has come,' the Walrus said,
    'To talk of many things:
    Of shoes -- and ships -- and sealing-wax --
    Of cabbages -- and kings --
    And why the sea is boiling hot --
    And whether pigs have wings.'
    """;

Text Blocks verwenden

Preview Feature

Text Blocks existieren als Preview Feature in Java. Um sie in Java Code verwenden zu können, müssen Sie die Flags --enable-preview und -source 13 sowie --enable-preview auf der Java-Kommandozeile verwenden:

javac --enable-preview -source 13 -d classes TextBlockExample.java
java --enable-preview -cp classes com.example.TextBlockExample

Die Verwendung von jshell zum Experimentieren mit Text Blocks erfordert auch die Verwendung von --enable-preview-Flags:

jshell --enable-preview

Verwenden Sie die Flags --enable-preview und --source (Hinweis: zwei Bindestriche) mit dem Java-Befehl, um eine einzelne Quelldatei zu kompilieren und mit einem Hauptprogramm auszuführen:

java --enable-preview --source 13 TextBlockExample.java

(Single-File-Quellcode-Programme sind in JEP 330 beschrieben.)

Syntax der Text Blocks

Ein Text Block beginnt mit drei doppelten Anführungszeichen, gefolgt von einem Zeilenabschluss. Es ist weder möglich, einen Text Block in einer einzigen Zeile zu platzieren, noch kann der Inhalt des Text Blocks in den drei geöffneten doppelten Anführungszeichen stehen, ohne dass ein dazwischenliegender Zeilenabschluss erfolgt. Der Grund dafür ist, dass Text Blocks in erster Linie für die Unterstützung mehrzeiliger Strings konzipiert sind. Die Vorgabe des anfänglichen Zeilenterminators vereinfacht die Regeln für die Behandlung von Einrückungen (siehe den Abschnitt unten, „Incidental White Space“).

// ERROR
String name = """Pat Q. Smith""";

// ERROR
String name = """red
                 green
                 blue
                 """;

// OK
String name = """
    red
    green
    blue
    """;

Dieses letzte Beispiel entspricht dem folgenden String-Literal:

String name = "red\n" +
              "green\n" +
              "blue\n";

Hier ist ein Beispiel für einen Ausschnitt aus Java Code innerhalb eines Text Blocks:

String source = """
    String message = "Hello, World!";
    System.out.println(message);
    """;

Beachten Sie, dass die eingebetteten doppelten Anführungszeichen weiterhin notwendig sind. Das entsprechende String-Literal wäre:

String source = "String message = \"Hello, World!\";\n" +
                "System.out.println(message);\n";

Final New Line

Beachten Sie, dass das obige Beispiel

String name = """
    red
    green
    blue
    """;

äquivalent zu "red\ngreen\nblue\n" ist. Wie kann nun ein mehrzeiliger String ohne das endgültige \n dargestellt werden?

String name = """
    red
    green
    blue""";

Dieser Text Block entspricht "red\ngreen\nblue". Wenn also das abschließende Trennzeichen auf die letzte sichtbare Zeile gesetzt wird, wird das letzte \n dadurch entfernt.

Incidental White Space

Im Idealfall wird ein Text Block eingerückt, um der Einrückung des umgebenden Codes zu entsprechen. Zum Beispiel:

void writeHTML() {
    String html = """
        
            
                

Hello World.

                              """;     writeOutput(html); }

Dies wirft jedoch die Frage auf, wie sich die für die Einrückung verwendeten Leerzeichen auf den Inhalt des Strings auswirken. Eine naive Interpretation würde all diesen White Space in den Text Block aufnehmen. Die Folge wäre, dass eine erneute Einrückung des Codes den Inhalt des Text Blocks beeinflussen würde. Dies würde höchstwahrscheinlich einen Fehler produzieren.

Um dieses Problem zu vermeiden, unterscheidet ein Text Block den zufälligen (incidental) White Space vom essentiellen (essential) White Space. Der Java Compiler entfernt automatisch den anfallenden White Space. Die Einrückung links von <html> und </html> gilt als zufällig, da diese Zeilen am wenigsten eingerückt sind. So bestimmen sie effektiv den linken Rand des Textes im Text Block. Die Einrückung von <body> in Bezug auf <html> wird jedoch nicht als Incidential White Space betrachtet. Vermutlich ist diese relative Einrückung als Teil des Inhalts des Strings vorgesehen.

Das folgende Beispiel verwendet "-", um den Incidental White Space zu visualisieren, wobei der Essential White Space als Actual White Space dargestellt wird.

void writeHTML() {
    String html = """
········<html>
········    <body>
········        <p>Hello World.</p>
········    </body>
········</html>
········""";
    writeOutput(html);
}

Nachdem der Incidental White Space entfernt wurde, sieht der Inhalt des Text Blocks wie folgt aus:

<html>
    <body>
        <p>Hello World.</p>
    </body>
</html>

Der Algorithmus zur Bestimmung des Incidental White Space wird in JEP 355 äußerst detailgenau beschrieben. Der Effekt ist jedoch recht einfach. Der gesamte Inhalt des Text Blocks wird nach links verschoben, bis die Zeile, mit dem am wenigsten Incidental White Space am Zeilenanfang, keinen mehr besitzt.

Um einen Teil des White Space zu erhalten (und zwar nicht als Incidental White Space), verschieben Sie einfach die Inhaltszeilen des Text Blocks nach rechts, während Sie das abschließende Dreifach-Anführungszeichen an der für den umgebenden Code geeigneten Einrückung belassen. Zum Beispiel:

void writeHTML() {
    String html = """
········    <html>
········        <body>
········            <p>Hello World.</p>
········        </body>
········    </html>
········""";
    writeOutput(html);
}

Dies führt zu folgendem Ergebnis:

  <html>
        <body>
            <p>Hello World.</p>
        </body>
    </html>

Ein Textblock kann sich vom Incidental White Space lösen, indem er das schließende Trennzeichen an der ersten Zeichenposition einer Quellzeile positioniert:

void writeHTML() {
    String html = """
                 <html>
                     <body>
                          <p>Hello World.</p>
                      </body>
                  </html>
""";
    writeOutput(html);
}

Das Ergebnis ist, dass es keinen zu entfernenden Incidental White Space mehr gibt und der String auf jeder Zeile zu Beginn einen Incidental White Space enthält.

  <html>
                      <body>
                          <p>Hello World.</p>
                      </body>
                  </html>

Diese Technik zur Steuerung der Einrückung funktioniert nur, wenn die letzte Zeile des Text Blocks mit einem Zeilenabschluss endet. Wenn die letzte Zeile nicht mit einem Zeilenabschluss endet, müssen Sie String::indent verwenden, um die Einrückung explizit zu steuern. Im folgenden Beispiel:

String colors = """
    red
    green
    blue""";

wird die gesamte Einrückung wird als incidental behandelt und entfernt:

red
green
blue

Um eine Einrückung in den Inhalt der Zeichenkette aufzunehmen, rufen Sie die indent-Methode im Text Block auf:

String colors = """
    red
    green
    blue""".indent(4);

Das Ergebnis ist:

   red
    green
    blue

Trailing White Space

In jeder Zeile eines Text Blocks gelten Trailing White Spaces als incidental und werden vom Java Compiler entfernt. Dies geschieht so, dass der Inhalt des Text Blocks immer optisch erkennbar ist. Wenn dies nicht geschieht, könnte ein Texteditor, der automatisch Trailings entfernt, den Inhalt eines Text Blocks unbemerkt verändern.
Wenn Sie in einem Text Block Trailing White Space verwenden müssen, können Sie eine der folgenden Strategien verwenden:

// character substitution
String r = """
    trailing$$$
    white space
    """.replace('$', ' ');
// character fence
String s = """
    trailing   |
    white space|
    """.replace("|\n", "\n");
// octal escape sequence for space
String t = """
    trailing\040\040\040
    white space
    """;

Hinweis: \u0020 kann nicht verwendet werden, da Unicode Escapes bereits früh beim Lesen der Quelldatei vor der lexikalischen Analyse übersetzt werden. Im Gegensatz dazu werden Zeichen- und String-Escapes wie \040 verarbeitet, nachdem die lexikalische Analyse die Quelldatei in Token unterteilt und String-Literale und Text Blocks identifiziert hat.

Erkennen potenzieller Probleme von White Spaces

In den vorhergehenden Beispielen bestand jede Einrückung aus Leerzeichen. Manchmal verwenden man jedoch TAB \t Zeichen. Leider ist es dem Java Compiler nicht möglich zu wissen, wie Tabulatorzeichen in verschiedenen Editoren angezeigt werden. Daher gilt die Regel, dass jedes einzelne Leerzeichen gleichbehandelt wird. Ein einzelnes Leerzeichen wird wie ein einzelnes Tabulatorzeichen behandelt, auch wenn letzteres zu Leerzeichen führen kann, die bei der Anzeige auf einem bestimmten System bis zu acht Leerzeichen entsprechen können.

Daraus folgt, dass das Mischen von Leerzeichen inkonsistente und unbeabsichtigte Auswirkungen haben kann. Betrachten Sie das folgende Beispiel, in dem einige Zeilen mit Leerzeichen und andere mit Tabs eingerückt sind (die mit visualisiert sind):

    String colors = """
····················red
␉   ␉   ␉   ␉   ␉   green
····················blue""";

In diesem Fall wäre das Entfernen der Einrückung ungleichmäßig, da die zweite Zeile nur fünf Leerzeichen und die anderen zwanzig aufweist. Das Ergebnis würde in etwa so aussehen:

              red
green
               blue

Es ist möglich, Probleme im Zusammenhang mit Incidental White Spaces zu erkennen, indem Sie die Text Block Lint Detection mit dem Lint-Flag -Xlint:text-blocks des Java Compilers aktivieren. Wenn die Lint Detection aktiviert ist, erzeugt das obige Beispiel die Warnung "inconsistent white space indentation".

Dieses Lint-Flag ermöglicht auch eine weitere Warnung, "trailing white space will be removed", die ausgegeben wird, wenn der White Space in einer Zeile innerhalb eines Text Blocks liegt. Wenn Sie den Trailing White Space erhalten möchten, verwenden Sie eine der im obigen Abschnitt beschriebenen Escape- oder Ersatztechniken.

W-JAX 2019 Java-Dossier für Software-Architekten

Kostenlos: Java-Dossier für Software-Architekten 2019

Auf über 30 Seiten vermitteln Experten praktisches Know-how zu den neuen Valuetypes in Java 12, dem Einsatz von Service Meshes in Microservices-Projekten, der erfolgreichen Einführung von DevOps-Praktiken im Unternehmen und der nachhaltigen JavaScript-Entwicklung mit Angular und dem WebComponents-Standard.

 

Standardisierung von Line-Terminatoren

Eine der Komplikationen eines mehrzeiligen String-Literals besteht darin, dass der in der Quelldatei verwendete Zeilenabschluss (\n, \r oder \r\n) von Plattform zu Plattform unterschiedlich ist. Editoren auf verschiedenen Plattformen können die Line-Terminatoren unbemerkt verändern. Oder, wenn eine Quelldatei auf verschiedenen Plattformen bearbeitet wird, kann ein Text Block eine Mischung aus verschiedenen Zeilenabschlüssen enthalten. Dies führt wahrscheinlich zu missverständlichen und inkonsistenten Ergebnissen.

Um diese Probleme zu vermeiden, standardisiert der Java-Compiler alle Zeilenabschlüsse in einem Text Block auf \n, unabhängig davon, welche Zeilenabschlüsse tatsächlich in der Quelldatei erscheinen. Der folgende Textblock (wobei und für \n und \r stehen):

String colors = """
    red␊
    green␍
    blue␍␊
    """;

ist äquivalent zu diesem String-Literal:

String colors = "red\ngreen\nblue\n";

Falls ein Plattform Line Terminator erforderlich ist, kann String::replaceAll("\n", System.lineSeparator()) verwendet werden.

Übersetzung von Escape-Sequenzen

Wie bei String-Literalen erkennen Text Blocks die Escape-Sequenzen \b, \f, \n, \t, \r, \", \', \\ und oktale Escapes. Im Gegensatz zu String-Literalen sind Escape-Sequenzen oft nicht erforderlich. In den meisten Fällen können die eigentlichen Zeichen \n, \t, \" und \' anstelle von Escape-Sequenzen verwendet werden. Der folgende Text Block (wobei und für \t und \n stehen):

String s = """
    Color␉   Shape␊
    Red␉ ␉   Circle␊
    Green␉   Square␊
    Blue␉␉   Triangle␊
    """;

wird zu:

Color␉  Shape␊
Red␉ ␉  Circle␊
Green␉  Square␊
Blue␉␉  Triangle␊

Eine Escape-Funktion ist erforderlich, wenn drei oder mehr doppelte Anführungszeichen nacheinander auftreten.

String code = """
    String source = \"""
        String message = "Hello, World!";
        System.out.println(message);
        \""";
    """;

Die Escape-Übersetzung erfolgt als letzter Schritt der Verarbeitung durch den Java Compiler, sodass die Schritte der Standardisierung von Line-Terminatoren und White Space Stripping umgangen werden können, indem explizite Escape-Sequenzen verwendet werden. Zum Beispiel:

String s = """
           red  \040
           green\040
           blue \040
           """;

Dies würde garantieren, dass alle Zeilen gleich lang sind, da die \040 erst nach dem Entfernen des Trailing White Space in ein Leerzeichen umgewandelt wird ("-" wird verwendet, um den Trailing Space anzuzeigen). Das Ergebnis ist:

red···
green·
blue··

Hinweis: Wie bereits erwähnt, kann die Unicode-Escape-Sequenz \u0020 nicht als Ersatz für \040 verwendet werden.

Style Guidelines für Text Blocks


Guideline #1

Sie sollten einen Text Block verwenden, wenn er die Übersichtlichkeit des Codes verbessert, insbesondere bei mehrzeiligen Strings.

// ORIGINAL
String message = "'The time has come,' the Walrus said,\n" +
                 "'To talk of many things:\n" +
                 "Of shoes -- and ships -- and sealing-wax --\n" +
                 "Of cabbages -- and kings --\n" +
                 "And why the sea is boiling hot --\n" +
                 "And whether pigs have wings.'\n";

// BETTER
String message = """
    'The time has come,' the Walrus said,
    'To talk of many things:
    Of shoes -- and ships -- and sealing-wax --
    Of cabbages -- and kings --
    And why the sea is boiling hot --
    And whether pigs have wings.'
    """;

Guideline #2

Wenn ein String in eine einzelne Zeile passt, ohne Verkettung und ohne Zeilenumbrüche, sollten Sie weiterhin ein String-Literal verwenden.

// ORIGINAL - is a text block helpful here?
String name = """
              Pat Q. Smith""";

// BETTER - a string literal works fine
String name = "Pat Q. Smith";

Guideline #3

Verwenden Sie eingebettete Escape-Sequenzen, wenn sie die Lesbarkeit gewährleisten.

var data = """
    Name | Address | City
    Bob Smith | 123 Anytown St\nApt 100 | Vancouver
    Jon Brown | 1000 Golden Place\nSuite 5 | Santa Ana
    """;

Guideline #4

Bei den meisten mehrzeiligen Strings platzieren Sie das öffnende Trennzeichen am rechten Ende der vorherigen Zeile und das abschließende Trennzeichen auf einer eigenen Zeile am linken Rand des Text Blocks.

String string = """
    red
    green
    blue
    """;

Guideline #5

Vermeiden Sie es, die Begrenzungszeichen für das Öffnen und Schließen am linken Rand des Text Blocks auszurichten. Dies erfordert eine Neueinrückung des Text Blocks, wenn der Variablenname oder die Modifikatoren geändert werden.

// ORIGINAL
String string = """
                red
                green
                blue
                """;

// ORIGINAL - after variable declaration changes
static String rgbNames = """
                         red
                         green
                         blue
                         """;

// BETTER
String string = """
    red
    green
    blue
    """;

// BETTER - after variable declaration changes
static String rgbNames = """
    red
    green
    blue
    """;

Guideline #6

Vermeiden Sie Inline Text Blocks innerhalb komplexer Ausdrücke, da dies die Lesbarkeit beeinträchtigen kann. Erwägen Sie das Refactoring auf eine lokale Variable oder auf ein statisches Endfeld.

// ORIGINAL
String poem = new String(Files.readAllBytes(Paths.get("jabberwocky.txt")));
String middleVerses = Pattern.compile("\\n\\n")
                             .splitAsStream(poem)
                             .match(verse -> !"""
                                   ’Twas brillig, and the slithy toves
                                   Did gyre and gimble in the wabe;
                                   All mimsy were the borogoves,
                                   And the mome raths outgrabe.
                                   """.equals(verse))
                             .collect(Collectors.joining("\n\n"));

// BETTER
String firstLastVerse = """
    ’Twas brillig, and the slithy toves
    Did gyre and gimble in the wabe;
    All mimsy were the borogoves,
    And the mome raths outgrabe.
    """;
String poem = new String(Files.readAllBytes(Paths.get("jabberwocky.txt")));
String middleVerses = Pattern.compile("\\n\\n")
                             .splitAsStream(poem)
                             .match(verse -> !firstLastVerse.equals(verse))
                             .collect(Collectors.joining("\n\n"));

Guideline #7

Verwenden Sie entweder nur Leerzeichen oder nur Tabulatoren für die Einrückung eines Text Blocks. Das Mischen von Leerzeichen führt zu einem Ergebnis mit unregelmäßiger Einrückung.

// ORIGINAL
    String colors = """
········red
␉       green
········blue""";    // result: "·······red\ngreen\n·······blue"

// PROBABLY WHAT WAS INTENDED
    String colors = """
········red
········green
········blue""";    // result: "red\ngreen\nblue"

Guideline #8

Wenn eine Text-Block-Sequenz drei oder mehr doppelte Anführungszeichen enthält, überspringen Sie das erste doppelte Anführungszeichen von jedem Durchlauf von drei doppelten Anführungszeichen.

// ORIGINAL
String code = """
    String source = \"\"\"
        String message = "Hello, World!";
        System.out.println(message);
        \"\"\";
    """;

// BETTER
String code = """
    String source = \"""
        String message = "Hello, World!";
        System.out.println(message);
        \""";
    """;

Guideline #9

Die meisten Textblöcke sollten eingerückt werden, um sich am benachbarten Java Code auszurichten.

   // ORIGINAL - odd indentation
    void printPoem() {
        String poem = """
’Twas brillig, and the slithy toves
Did gyre and gimble in the wabe;
All mimsy were the borogoves,
And the mome raths outgrabe.
""";
        System.out.print(poem);
    }

    // BETTER
    void printPoem() {
        String poem = """
            ’Twas brillig, and the slithy toves
            Did gyre and gimble in the wabe;
            All mimsy were the borogoves,
            And the mome raths outgrabe.
            """;
        System.out.print(poem);
    }

Guideline #10

Es wird empfohlen, einen breiten String vollständig links auszurichten, um horizontales Scrollen oder einen Zeilenumbruch zu vermeiden.

// ORIGINAL

class Outer {
    class Inner {
        void printPoetry() {
            String lilacs = """
                Over the breast of the spring, the land, amid cities,
                Amid lanes and through old woods, where lately the violets peep’d from the ground, spotting the gray debris,
                Amid the grass in the fields each side of the lanes, passing the endless grass,
                Passing the yellow-spear’d wheat, every grain from its shroud in the dark-brown fields uprisen,
                Passing the apple-tree blows of white and pink in the orchards,
                Carrying a corpse to where it shall rest in the grave,
                Night and day journeys a coffin.
                """;
            System.out.println(lilacs);
        }
    }
}

// BETTER

class Outer {
    class Inner {
        void printPoetry() {
            String lilacs = """
Over the breast of the spring, the land, amid cities,
Amid lanes and through old woods, where lately the violets peep’d from the ground, spotting the gray debris,
Amid the grass in the fields each side of the lanes, passing the endless grass,
Passing the yellow-spear’d wheat, every grain from its shroud in the dark-brown fields uprisen,
Passing the apple-tree blows of white and pink in the orchards,
Carrying a corpse to where it shall rest in the grave,
Night and day journeys a coffin.
""";
            System.out.println(lilacs);
        }
    }
}

Guideline #11

Ebenso ist es sinnvoll, einen Text Block vollständig linksbündig auszurichten, wenn eine hohe Zeilenzahl dazu führt, dass das abschließende Trennzeichen wahrscheinlich vertikal aus der Sicht scrollt. Dies ermöglicht es dem Leser, die Einrückung am linken Rand zu verfolgen, wenn das schließende Trennzeichen nicht sichtbar ist.

// ORIGINAL

String validWords = """
                    aa
                    aah
                    aahed
                    aahing
                    aahs
                    aal
                    aalii
                    aaliis
...
                    zythum
                    zythums
                    zyzzyva
                    zyzzyvas
                    zzz
                    zzzs
                    """;

// BETTER

String validWords = """
aa
aah
aahed
aahing
aahs
aal
aalii
aaliis
...
zythum
zythums
zyzzyva
zyzzyvas
zzz
zzzs
""";

Preview von String-Methoden

Mehrere neue Methoden sind in der String-Klasse als Teil der Preview Functions für Text Blocks enthalten. Beachten Sie, dass diese Methoden zum Entfernen als Deprecated markiert sind, um anzuzeigen, dass sie Teil einer Preview Function sind.

String formatted

Diese Methode ist äquivalent zu String.format. Der Vorteil ist, dass sie als Instanzmethode am Ende eines Text Blocks angehängt werden kann:

String output = """
    Name: %s
    Phone: %s
    Address: %s
    Salary: $%.2f
    """.formatted(name, phone, address, salary);

String stripIndent()

Das stripIndent-Verfahren entfernt Incidental White Space aus einem mehrzeiligen String mit dem gleichen Algorithmus, der vom Java Compiler verwendet wird. Dies ist nützlich, wenn Sie ein Programm haben, das Text als Eingabedaten liest, und Sie die Einrückung auf die gleiche Weise entfernen möchten wie bei den Text Blocks.

String translateEscapes()

Die translateEscapes-Methode führt die Übersetzung von Escape-Sequenzen durch (\b, \f, \n, \t, \r, \", \', \\ und oktale Escapes) und wird vom Java Compiler verwendet, um Text Blocks und String-Literale zu verarbeiten. Dies ist nützlich, wenn Sie ein Programm haben, das Text als Eingabedaten liest und eine Verarbeitung der Escape-Sequenz durchführen möchten. Beachten Sie, dass Unicode Escapes (\uNNNNNN) nicht verarbeitet werden.

Verwandte Themen:

Geschrieben von
Jim Laskey
Jim Laskey
Jim Laskey has been involved in developing computer language compilers and runtimes for over 44 years. He is currently Director of Software Development in the Java Language/Tools group at Oracle Corporation. Jim worked on the the first commercial JIT for Java, symcjit, and was involved in the early stages of the LLVM project. Jim has also worked on compilers and runtimes at Sun, Azul, Apple, Symantec, Prograph International and Dalhousie University. http://www.linkedin.com/in/jlaskey.
Stuart Marks
Stuart Marks
Stuart Marks is a Consulting Member of Technical Staff in the Java Platform Group at Oracle. He is currently working on a variety of JDK core libraries projects, including Collections, Lambda, and Streams, as well as improving test quality and performance. As his alter ego "Dr Deprecator" he also works on the Java SE deprecation mechanism. He has previously worked on JavaFX and Java ME at Sun Microsystems. He has over twenty years of software platform product development experience in the areas of window systems, interactive graphics, and mobile and embedded systems. Stuart holds a Master's degree in Computer Science and a Bachelor's degree in Electrical Engineering from Stanford University.
Kommentare

Hinterlasse einen Kommentar

Hinterlasse den ersten Kommentar!

avatar
4000
  Subscribe  
Benachrichtige mich zu: