Java 8: Formatierung von Lambda mit Zeilenumbrüchen und Einrückungen

Lesezeit: 16 Minuten

Benutzer-Avatar
EpicPandaForce

Was ich mit Lambda-Einrückung erreichen möchte, ist Folgendes:

Mehrzeilige Erklärung:

String[] ppl = new String[] { "Karen (F)", "Kevin (M)", "Lee (M)", "Joan (F)", "Des (M)", "Rick (M)" };
List<String> strings = Arrays.stream(ppl)
                         .filter(
                             (x) -> 
                             {
                                 return x.contains("(M)");
                             }
                         ).collect(Collectors.toList());
strings.stream().forEach(System.out::println);

Einzeilige Erklärung:

List<String> strings = Arrays.stream(ppl)
                         .map((x) -> x.toUpperCase())
                         .filter((x) -> x.contains("(M)"))
                         .collect(Collectors.toList());

Derzeit formatiert Eclipse automatisch wie folgt:

Mehrzeilige Erklärung:

String[] ppl = new String[] { "Karen (F)", "Kevin (M)", "Lee (M)", "Joan (F)", "Des (M)", "Rick (M)" };
List<String> strings = Arrays.stream(ppl).filter((x) ->
{
    return x.contains("(M)");
}).collect(Collectors.toList());
strings.stream().forEach(System.out::println);

Einzeilige Erklärung:

String[] ppl = new String[] { "Karen (F)", "Kevin (M)", "Lee (M)", "Joan (F)", "Des(M)", "Rick (M)" };
List<String> strings = Arrays.stream(ppl).map((x) -> x.toUpperCase())
        .filter((x) -> x.contains("(M)")).collect(Collectors.toList());
strings.stream().forEach(System.out::println);

Und ich finde das wirklich chaotisch, weil das so ist collect Anruf ist direkt darunter return und es gibt überhaupt keinen Zwischenraum. Mir wäre es lieber, wenn ich das Lambda in einer neuen Zeile eingerückt beginnen könnte, und damit die .filter( Anruf wäre direkt über dem .collect( Anruf. Das einzige, was mit dem Standard-Java-8-Eclipse-Formatter angepasst werden kann, ist die Klammer am Anfang des Lambda-Körpers, aber nichts für die () Klammern vorher, noch die Einrückung.

Und im Fall von einzeiligen Anrufen verwendet es nur den grundlegenden Zeilenumbruch und macht es zu einem verketteten Durcheinander. Ich glaube nicht, dass ich erklären muss, warum das hinterher schwer zu entschlüsseln ist.

Gibt es eine Möglichkeit, die Formatierung irgendwie weiter anzupassen und den ersten Formatierungstyp in Eclipse zu erreichen? (Oder optional in einer anderen IDE wie IntelliJ IDEA.)

BEARBEITEN: Am nächsten kam ich mit der IntelliJ IDEA 13 Community Edition (sprich: kostenlose Edition: P), die folgende war (definiert durch kontinuierliche Einrückung, die in diesem Fall 8 ist):

public static void main(String[] args)
{
    int[] x = new int[] {1, 2, 3, 4, 5, 6, 7};
    int sum = Arrays.stream(x)
            .map((n) -> n * 5)
            .filter((n) -> {
                System.out.println("Filtering: " + n);
                return n % 3 != 0;
            })
            .reduce(0, Integer::sum);

    List<Integer> list = Arrays.stream(x)
            .filter((n) -> n % 2 == 0)
            .map((n) -> n * 4)
            .boxed()
            .collect(Collectors.toList());
    list.forEach(System.out::println);
    System.out.println(sum);    

Es ermöglicht auch, den verketteten Methodenaufruf wie folgt “auszurichten”:

    int sum = Arrays.stream(x)
                    .map((n) -> n * 5)
                    .filter((n) -> {
                        System.out.println("Filtering: " + n);
                        return n % 3 != 0;
                    })
                    .reduce(0, Integer::sum);


    List<Integer> list = Arrays.stream(x)
                               .filter((n) -> n % 2 == 0)
                               .map((n) -> n * 4)
                               .boxed()
                               .collect(Collectors.toList());
    list.forEach(System.out::println);
    System.out.println(sum);
}

Ich persönlich finde, dass es zwar sinnvoller ist, aber die zweite Version es viel zu weit wegschiebt, also bevorzuge ich die erste.

Das Setup, das für das erste Setup verantwortlich ist, ist das Folgende:

<?xml version="1.0" encoding="UTF-8"?>
<code_scheme name="Zhuinden">
  <option name="JD_ALIGN_PARAM_COMMENTS" value="false" />
  <option name="JD_ALIGN_EXCEPTION_COMMENTS" value="false" />
  <option name="JD_ADD_BLANK_AFTER_PARM_COMMENTS" value="true" />
  <option name="JD_ADD_BLANK_AFTER_RETURN" value="true" />
  <option name="JD_P_AT_EMPTY_LINES" value="false" />
  <option name="JD_PARAM_DESCRIPTION_ON_NEW_LINE" value="true" />
  <option name="WRAP_COMMENTS" value="true" />
  <codeStyleSettings language="JAVA">
    <option name="KEEP_FIRST_COLUMN_COMMENT" value="false" />
    <option name="BRACE_STYLE" value="2" />
    <option name="CLASS_BRACE_STYLE" value="2" />
    <option name="METHOD_BRACE_STYLE" value="2" />
    <option name="ELSE_ON_NEW_LINE" value="true" />
    <option name="WHILE_ON_NEW_LINE" value="true" />
    <option name="CATCH_ON_NEW_LINE" value="true" />
    <option name="FINALLY_ON_NEW_LINE" value="true" />
    <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
    <option name="SPACE_WITHIN_BRACES" value="true" />
    <option name="SPACE_BEFORE_IF_PARENTHESES" value="false" />
    <option name="SPACE_BEFORE_WHILE_PARENTHESES" value="false" />
    <option name="SPACE_BEFORE_FOR_PARENTHESES" value="false" />
    <option name="SPACE_BEFORE_TRY_PARENTHESES" value="false" />
    <option name="SPACE_BEFORE_CATCH_PARENTHESES" value="false" />
    <option name="SPACE_BEFORE_SWITCH_PARENTHESES" value="false" />
    <option name="SPACE_BEFORE_SYNCHRONIZED_PARENTHESES" value="false" />
    <option name="SPACE_BEFORE_ARRAY_INITIALIZER_LBRACE" value="true" />
    <option name="METHOD_PARAMETERS_WRAP" value="1" />
    <option name="EXTENDS_LIST_WRAP" value="1" />
    <option name="THROWS_LIST_WRAP" value="1" />
    <option name="EXTENDS_KEYWORD_WRAP" value="1" />
    <option name="THROWS_KEYWORD_WRAP" value="1" />
    <option name="METHOD_CALL_CHAIN_WRAP" value="2" />
    <option name="BINARY_OPERATION_WRAP" value="1" />
    <option name="BINARY_OPERATION_SIGN_ON_NEXT_LINE" value="true" />
    <option name="ASSIGNMENT_WRAP" value="1" />
    <option name="IF_BRACE_FORCE" value="3" />
    <option name="DOWHILE_BRACE_FORCE" value="3" />
    <option name="WHILE_BRACE_FORCE" value="3" />
    <option name="FOR_BRACE_FORCE" value="3" />
    <option name="PARAMETER_ANNOTATION_WRAP" value="1" />
    <option name="VARIABLE_ANNOTATION_WRAP" value="1" />
    <option name="ENUM_CONSTANTS_WRAP" value="2" />
  </codeStyleSettings>
</code_scheme>

Ich habe versucht, sicherzustellen, dass alles vernünftig ist, aber ich habe möglicherweise etwas durcheinander gebracht, sodass möglicherweise geringfügige Anpassungen erforderlich sind.

Wenn Sie wie ich Ungar sind und ein ungarisches Layout verwenden, könnte Ihnen diese Tastenbelegung nützlich sein, damit Sie AltGR+F, AltGR+G, AltGR+B nicht am Ende nicht verwenden können , AltGR+N und AltGR+M (entspricht Strg+Alt).

<?xml version="1.0" encoding="UTF-8"?>
<keymap version="1" name="Default copy" parent="$default">
  <action id="ExtractMethod">
    <keyboard-shortcut first-keystroke="shift control M" />
  </action>
  <action id="GotoImplementation">
    <mouse-shortcut keystroke="control alt button1" />
  </action>
  <action id="GotoLine">
    <keyboard-shortcut first-keystroke="shift control G" />
  </action>
  <action id="Inline">
    <keyboard-shortcut first-keystroke="shift control O" />
  </action>
  <action id="IntroduceField">
    <keyboard-shortcut first-keystroke="shift control D" />
  </action>
  <action id="Mvc.RunTarget">
    <keyboard-shortcut first-keystroke="shift control P" />
  </action>
  <action id="StructuralSearchPlugin.StructuralReplaceAction" />
  <action id="Synchronize">
    <keyboard-shortcut first-keystroke="shift control Y" />
  </action>
</keymap>

IntelliJ scheint zwar keine Möglichkeit zu bieten, die öffnende geschweifte Klammer des Lambda in eine neue Zeile einzufügen, aber ansonsten ist es eine ziemlich vernünftige Art der Formatierung, also werde ich dies als akzeptiert markieren.

  • Kannst du nicht verwenden .filter(x -> x.contains("(M)"))? Viel einfacher … Wenn ja eigentlich Wenn wir über Stellen sprechen, an denen Sie mehrere Anweisungen benötigen, wäre es besser, ein Beispiel zu geben, wo dies erforderlich ist.

    – Jon Skeet

    9. Juli 2014 um 9:31 Uhr


  • @JonSkeet Ich konnte mir gerade keinen wirklich guten Anwendungsfall für mehrere Zeilen vorstellen, aber ich habe stattdessen beide Fälle hinzugefügt.

    – EpicPandaForce

    9. Juli 2014 um 9:44 Uhr

  • Ehrlich gesagt, die ‘Netbeans 8.0’-Version, die jemand unten gepostet und gelöscht hat, war wirklich nah an der Wahrheit, obwohl Netbeans dafür berüchtigt ist, dass es nicht erlaubt, die öffnenden geschweiften Klammern von Anweisungen im Allman-Stil richtig zu formatieren.

    – EpicPandaForce

    9. Juli 2014 um 9:48 Uhr

  • Ich denke, die aktuelle Lösung aktiviert “nie umbrochene Zeilen verbinden” und formatiert von Hand, aber das scheint im Vergleich zum Drücken etwas mühsam zu sein Ctrl+Alt+F wenn Sie den Code einer anderen Person automatisch formatieren.

    – EpicPandaForce

    9. Juli 2014 um 9:58 Uhr

  • Und aus irgendeinem Grund hatte Eclipse Probleme damit, den Typ von herauszufinden x ohne die geschweiften Klammern zu öffnen und zu schließen, weshalb ich zunächst eine Anweisung anstelle der einfachen Version verwendet habe.

    – EpicPandaForce

    9. Juli 2014 um 15:06 Uhr

In Eclipse für die einzeiligen Anweisungen:

Gehen Sie in Ihrem Projekt oder in den globalen Einstellungen zu Java -> Code Style -> Formatter -> Edit -> Line Wrapping -> Function Calls -> Qualified Invocationseinstellen Wrap all elements, except first if not necessary und ankreuzen Force split, even if line shorter than maximum line width.

  • Hey, das scheint in Ordnung zu sein, außer, ich bin gezwungen, das auch einzurücken, entweder mit Standardeinzug oder Spalte oder 1. Das macht keinen Sinn. Meine Einrückung unterscheidet sich je nach Strom. Beispiel: final List Tage = MappedSelect.query(“gameDays”, DataRow.class) .param(“seasonId”, 20142015) .select(context); Für das Obige möchte ich, dass die nächsten 2 Zeilen genau auf dem vorherigen Zeilenpunkt eingerückt werden.

    – Saravana Kumar M

    21. Dezember 2016 um 23:51 Uhr


  • Fast perfekt! 🙂 Manchmal wickelt es sich aber für meinen Geschmack zu sehr ein: Anweisungen innerhalb des Lambda, zB .filter(c -> c.getValue().equals(newValue)) wird auch kurz vor dem .equals umbrochen. Wäre schön, wenn eine solche Einstellung nur für Lambda-bezogene Methoden gelten würde; Ich sehe, dass dies schwierig zu implementieren sein könnte, obwohl …

    – Dominik

    7. März 2018 um 8:45 Uhr


Benutzer-Avatar
Mike Rylander

Out of the Box IntelliJ 13 wird wahrscheinlich für Sie funktionieren.

Wenn ich es so schreibe:

// Mulit-Line Statement
String[] ppl = new String[] { "Karen (F)", "Kevin (M)", "Lee (M)", "Joan (F)", "Des (M)", "Rick (M)" };
List<String> strings = Arrays.stream(ppl)
        .filter(
                (x) ->
                {
                    return x.contains("(M)");
                }
        ).collect(Collectors.toList());
strings.stream().forEach(System.out::println);

Und wenden Sie dann den automatischen Formatierer an (keine Änderungen):

// Mulit-Line Statement
String[] ppl = new String[]{"Karen (F)", "Kevin (M)", "Lee (M)", "Joan (F)", "Des (M)", "Rick (M)"};
List<String> strings = Arrays.stream(ppl)
        .filter(
                (x) ->
                {
                    return x.contains("(M)");
                }
        ).collect(Collectors.toList());
strings.stream().forEach(System.out::println);

Dasselbe gilt für Ihre einzeilige Erklärung. Meiner Erfahrung nach ist IntelliJ flexibler bei der Anwendung der automatischen Formatierung. Es ist weniger wahrscheinlich, dass IntelliJ Zeilenumbrüche entfernt oder hinzufügt, wenn Sie es dort ablegen, geht es davon aus, dass Sie es dort ablegen wollten. IntelliJ passt Ihren Tab-Space gerne für Sie an.


IntelliJ kann auch so konfiguriert werden, dass es einiges davon für Sie erledigt. Unter “Einstellungen” -> “Codestil” -> “Java” im Reiter “Wrapping and Braces” können Sie “chain method calls” auf “wrap always” setzen.

Vor der automatischen Formatierung

// Mulit-Line Statement
List<String> strings = Arrays.stream(ppl).filter((x) -> { return x.contains("(M)"); }).collect(Collectors.toList());

// Single-Line Statement
List<String> strings = Arrays.stream(ppl).map((x) -> x.toUpperCase()).filter((x) -> x.contains("(M)")).collect(Collectors.toList());

Nach der automatischen Formatierung

// Mulit-Line Statement
List<String> strings = Arrays.stream(ppl)
        .filter((x) -> {
            return x.contains("(M)");
        })
        .collect(Collectors.toList());

// Single-Line Statement
List<String> strings = Arrays.stream(ppl)
        .map((x) -> x.toUpperCase())
        .filter((x) -> x.contains("(M)"))
        .collect(Collectors.toList());

  • Die Frage ist, ist es in der Lage, es automatisch auf diese Weise zu formatieren? Es vereinfacht das Problem, wenn die automatische Formatierung gute Arbeit leistet, um es so zu formatieren, wie ich den Code gerne formatiere, auf diese Weise ist jeder Code einfacher zu lesen, sogar der Code eines anderen.

    – EpicPandaForce

    19. Juli 2014 um 20:07 Uhr

  • @Zhuinden Ich habe die Antwort mit einem Beispiel aktualisiert, wie dies für eine einzeilige Anweisung zu tun ist. Wie gezeigt, funktioniert es bis zu einem gewissen Grad auch für die mehrzeilige Anweisung. Es gibt viele, viele Optionen zum Konfigurieren des automatischen Formatierers von IntelliJ. Sie könnten ihn wahrscheinlich so verfeinern, dass er genau so aussieht, wie Sie ihn in Ihrer Frage haben.

    – Mike Rylander

    19. Juli 2014 um 21:28 Uhr

  • Ich habe die Dinge gemäß dem XML eingerichtet, das ich oben eingefügt habe. Ich denke, ich werde IntelliJ anstelle von Eclipse für alles verwenden, was nicht Android ist. Vielen Dank.

    – EpicPandaForce

    20. Juli 2014 um 15:34 Uhr


  • @EpicPandaForce, warum würdest du es nicht auch für Android verwenden?

    – ihr Mann

    25. November 2014 um 16:59 Uhr

  • @herman technisch gesehen habe ich seitdem auch angefangen, Android Studio für Android zu verwenden. Ich musste ein paar zusätzliche Gigs RAM installieren, aber die Firma hatte etwas herumliegen, also friert Gradle jetzt mit 8 GB nicht den ganzen Computer ein, während er kompiliert: P

    – EpicPandaForce

    25. November 2014 um 23:24 Uhr

Eclipse (Mars) hat eine Option für den Formatierer von Lambda-Ausdrücken.

Gehe zu Window > Preferences > Java > Code Style > Formatter

Geben Sie hier die Bildbeschreibung ein

Drücke den Edit Schaltfläche, gehen Sie zu Braces Markieren und setzen Sie die Lambda Body zu Next Line Indented

Geben Sie hier die Bildbeschreibung ein

Eine weitere Option besteht darin, diese Eigenschaften in Ihren Projekteinstellungen zu aktualisieren. (yourWorkspace > yourProject > .settings > org.eclipse.jdt.core.prefs)

org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert
org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=next_line_shifted

  • Dies scheint nur bei eingeklammerten Lambdas zu helfen.

    – Nik

    10. Februar 2016 um 22:31 Uhr

  • Das Aktualisieren dieser Eigenschaften hilft nicht

    – Piotr Wittchen

    4. Februar 2019 um 10:48 Uhr

Benutzer-Avatar
davidxxx

Diese Frage ist nun alt und leider ist die Standardkonfiguration des Eclipse-Formatierers immer noch nicht benutzerfreundlich, um funktionalen Code lesbar zu schreiben.

Ich habe alle Dinge ausprobiert, die in allen anderen Antworten erwähnt wurden, und niemand ist für die meisten Anwendungsfälle geeignet.
Für manche mag es in Ordnung sein, für andere unangenehm.

Ich habe einen Weg gefunden, der am meisten zu mir passt.
Ich teile es, indem ich denke, dass es anderen helfen könnte.

Beachten Sie, dass mein Weg einen Kompromiss hat: Akzeptieren, dass jeder qualifizierte Aufruf immer auf einer bestimmten Linie steht.
Es ist vielleicht die fehlende Option in der Formatiererkonfiguration: Angabe des Schwellenwerts in Bezug auf Aufrufe, um die Zeile zu umbrechen, anstatt sie zu verwenden 1 Aufruf standardmäßig.

Hier sind meine 2 kombinierten Tools, um damit richtig umzugehen:

  • Anpassen der Eclipse-Formatiererkonfiguration für die meisten Fälle

  • Erstellen einer Codevorlage mit //@formatter:off ... //@formatter:on für Eckfälle.


Anpassen der Konfiguration des Eclipse-Formatierers

Die zu ändernden Werte sind in der Aufnahme rot umrandet.

Schritt 1) ​​Erstellen Sie Ihren eigenen Java Code Style Formatter

Preferences Menü und im Baum zu gehen Java -> Code Style -> Formatter.
Klicken Sie auf „Neu“, um eine neue zu erstellen Profile (mit “Java-Konventionen initialisieren”).

Eclipse-Formatierer

Die beiden nächsten Schritte müssen in Ihrem benutzerdefinierten Formatierungsprofil durchgeführt werden.

Schritt 2) Ändern Sie die Einzugskonfiguration für umbrochene Zeilen

Identifikationskonfiguration

Die Modifikation ermöglicht die Verwendung von Whitespaces anstelle von Tabulatoren.
Dies spielt im nächsten Schritt eine Rolle, wenn wir die Zeilenumbruchrichtlinie mit der Spalteneinrückungsoption konfigurieren.
Es wird tatsächlich vermieden, dass unangenehme Zwischenräume entstehen.

Schritt 3) Ändern Sie den Standardeinzug für Zeilenumbrüche und die Zeilenumbruchrichtlinie für qualifizierte Aufrufe

Größe der umbrochenen Zeile


Hier ist eine Testformatierung mit Code der Frage.

Vor dem Formatieren:

void multiLineStatements() {
    String[] ppl = new String[] { "Karen (F)", "Kevin (M)", "Lee (M)", "Joan (F)", "Des (M)", "Rick (M)" };
    List<String> strings = Arrays.stream(ppl).filter((x) ->
    {
        return x.contains("(M)");
    }).collect(Collectors.toList());
    strings.stream().forEach(System.out::println);
}

void singleLineStatements() {
    String[] ppl = new String[] { "Karen (F)", "Kevin (M)", "Lee (M)", "Joan (F)", "Des(M)", "Rick (M)" };
    List<String> strings = Arrays.stream(ppl).map((x) -> x.toUpperCase())
            .filter((x) -> x.contains("(M)")).collect(Collectors.toList());
    strings.stream().forEach(System.out::println);
}

Nach dem Formatieren:

void multiLineStatements() {
    String[] ppl = new String[] { "Karen (F)", "Kevin (M)", "Lee (M)", "Joan (F)", "Des (M)", "Rick (M)" };
    List<String> strings = Arrays.stream(ppl)
                                 .filter((x) -> {
                                     return x.contains("(M)");
                                 })
                                 .collect(Collectors.toList());
    strings.stream()
           .forEach(System.out::println);
}

void singleLineStatements() {
    String[] ppl = new String[] { "Karen (F)", "Kevin (M)", "Lee (M)", "Joan (F)", "Des(M)", "Rick (M)" };
    List<String> strings = Arrays.stream(ppl)
                                 .map((x) -> x.toUpperCase())
                                 .filter((x) -> x.contains("(M)"))
                                 .collect(Collectors.toList());
    strings.stream()
           .forEach(System.out::println);
}

Erstellen von Codevorlagen mit //@formatter:off ... //@formatter:on für Eckfälle.

Manuelles Schreiben oder Copy-Paste //@formatter:on und //@formatter:off ist in Ordnung, da Sie es selten schreiben.
Aber wenn Sie es mehrmals pro Woche oder noch schlimmer täglich schreiben müssen, ist ein automatischerer Weg willkommen.

Schritt 1) ​​Gehen Sie zur Java-Editor-Vorlage

Preferences Menü und im Baum zu gehen Java ->Editor -> Template.
Geben Sie hier die Bildbeschreibung ein

Schritt 2) Erstellen Sie eine Vorlage, um die Formatierung für ausgewählten Code zu deaktivieren

Vorlagenformatierer aus an

Sie können es jetzt testen.
Wählen Sie Zeilen aus, deren Formatierung Sie deaktivieren möchten.
Jetzt eintreten ctrl+space zweimal (der erste ist “Java-Vorschläge” und der zweite ist “Vorlagenvorschläge”).
Sie sollten so etwas bekommen:

Vorlagenvorschlag

Wähle aus fmt Vorlage wie im Screenshot und klicken Sie auf “Enter”. Fertig!

Ergebnis nach Schablonenanwendung

Ich formatiere eine einzeilige Anweisung, indem ich nach Funktionen einen leeren Kommentar „//“ hinzufüge.

List<Integer> list = Arrays.stream(x) //
                           .filter((n) -> n % 2 == 0) //
                           .map((n) -> n * 4) //
                           .boxed() //
                           .collect(Collectors.toList());

  • Einfach und effektiv.

    – Steve

    24. April 2018 um 18:43 Uhr

  • Ich denke, es ist Lärm in Ihrer Codebasis, nur weil Sie keine Konfiguration im IDE-Stil festgelegt haben. Es kann für Leute verwirrend sein, die Ihre Codebasis zum ersten Mal betrachten.

    – Marc Bouvier

    17. September 2018 um 9:38 Uhr

  • Es geht nicht nur darum, eine IDE nicht einzustellen. Manchmal möchten Sie etwas besser sichtbar machen und es in eine neue Zeile einfügen. Und in vielen Fällen haben Sie aufgrund einer Unternehmens-/Projektrichtlinie keine Möglichkeit, den Formatierungsstil zu ändern. Dies ist also nur eine Option, wie man darauf verzichten kann formatter:off

    – Saljack

    27. Januar um 8:31 Uhr

Benutzer-Avatar
schlagen

Nicht ideal, aber Sie könnten den Formatierer nur für die Abschnitte ausschalten, die etwas dicht sind. Zum Beispiel

  //@formatter:off
  int sum = Arrays.stream(x)
        .map((n) -> n * 5)
        .filter((n) -> {
            System.out.println("Filtering: " + n);
            return n % 3 != 0;
        })
        .reduce(0, Integer::sum);
  //@formatter:on

Gehen Sie zu “Fenster > Einstellungen > Java > Codestil > Formatierer”. Klicken Sie auf die Schaltfläche “Bearbeiten…”, gehen Sie zur Registerkarte “Aus/Ein-Tags” und aktivieren Sie die Tags.

  • Einfach und effektiv.

    – Steve

    24. April 2018 um 18:43 Uhr

  • Ich denke, es ist Lärm in Ihrer Codebasis, nur weil Sie keine Konfiguration im IDE-Stil festgelegt haben. Es kann für Leute verwirrend sein, die Ihre Codebasis zum ersten Mal betrachten.

    – Marc Bouvier

    17. September 2018 um 9:38 Uhr

  • Es geht nicht nur darum, eine IDE nicht einzustellen. Manchmal möchten Sie etwas besser sichtbar machen und es in eine neue Zeile einfügen. Und in vielen Fällen haben Sie aufgrund einer Unternehmens-/Projektrichtlinie keine Möglichkeit, den Formatierungsstil zu ändern. Dies ist also nur eine Option, wie man darauf verzichten kann formatter:off

    – Saljack

    27. Januar um 8:31 Uhr

Benutzer-Avatar
Nosrep

Die Option, die für mich funktionierte, war das Ankreuzen Never join already wrapped lines Option im Abschnitt Zeilenumbruch des Formatierers in den Einstellungen.

1245120cookie-checkJava 8: Formatierung von Lambda mit Zeilenumbrüchen und Einrückungen

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy