जावा 8: लैंबडा को नए सिरे और इंडेंटेशन के साथ प्रारूपित करना

83

मेमना इंडेंटेशन के साथ मैं क्या हासिल करना चाहता हूं वह निम्नलिखित है:

बहु-पंक्ति विवरण:

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

एकल-पंक्ति विवरण:

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



वर्तमान में, ग्रहण निम्नलिखित के लिए स्वत: स्वरूपण कर रहा है:

बहु-पंक्ति विवरण:

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

एकल-पंक्ति विवरण:

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

और मुझे यह वास्तव में गन्दा लगता है, इस वजह से कि collectकॉल सीधे कैसे नीचे returnआती है और इसमें कोई स्पेस इनबेटन नहीं है। मैं इसे पसंद करूंगा अगर मैं एक नई लाइन में लंबू को इंडेंट कर सकता हूं, और ताकि .filter(कॉल कॉल के ठीक ऊपर हो .collect(। हालांकि, एकमात्र चीज जो मानक जावा -8 एक्लिप्स फॉर्मैटर के साथ अनुकूलित की जा सकती है, लैम्ब्डा बॉडी की शुरुआत में ब्रेस है, लेकिन ()पहले से ब्रैकेट्स के लिए कुछ भी नहीं , न ही इंडेंटेशन।

और सिंगल-लाइन कॉल के मामले में, यह मूल लाइन-रैप का उपयोग करता है और इसे एक जंजीर गड़बड़ बनाता है। मुझे नहीं लगता कि मुझे यह समझाने की आवश्यकता है कि इसके बाद डिक्रिप्ट करना कठिन क्यों है।

वहाँ किसी भी तरह से अधिक स्वरूपण को अनुकूलित करने और ग्रहण में पहले स्वरूपण प्रकार को प्राप्त करने का कोई तरीका है? (या, वैकल्पिक रूप से, इंटेलीज आईडीईए की तरह एक और आईडीई में।)



संपादित करें: मैं निकटतम हो सकता था इंटेलीज आईडीईए 13 सामुदायिक संस्करण (पढ़ें: नि: शुल्क संस्करण: पी) जो निम्नलिखित था (निरंतर इंडेंटेशन द्वारा परिभाषित किया गया था जो इस मामले में 8 है):

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

यह इस तरह से जंजीर विधि मंगाने को "संरेखित" करने की अनुमति देता है:

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

मुझे व्यक्तिगत रूप से लगता है कि जबकि यह अधिक समझ में आता है, दूसरा संस्करण इसे बहुत दूर धकेलता है, इसलिए मैं पहले वाले को पसंद करता हूं।

पहले सेटअप के लिए जिम्मेदार सेटअप निम्नलिखित है:

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

मैंने यह सुनिश्चित करने की कोशिश की कि सब कुछ उचित है, लेकिन मैंने कुछ गड़बड़ कर दी है, इसलिए इसे मामूली समायोजन की आवश्यकता हो सकती है।

यदि आप मेरी तरह हंगेरियन हैं और आप हंगेरियन लेआउट का उपयोग कर रहे हैं, तो यह कीमैप आपके काम आ सकता है, ताकि आप अंत में AltGR + F, AltGR + G, AltGR + B का उपयोग करने में सक्षम न हों। , AltGR + N और AltGR + M (जो Ctrl + 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>

जबकि इंटेलीज ने लैंबडा के शुरुआती ब्रेस को एक नई लाइन में डालने का एक तरीका प्रदान नहीं किया है, अन्यथा यह स्वरूपण का एक उचित तरीका है, इसलिए मैं इसे स्वीकार करूँगा।

java  eclipse  lambda  java-8  java-stream 
— EpicPandaForce
स्रोत
10
क्या आप उपयोग नहीं कर सकते .filter(x -> x.contains("(M)"))? बहुत सरल ... यदि आप वास्तव में उन स्थानों के बारे में बात कर रहे हैं, जहां आपको कई बयानों की आवश्यकता है, तो उदाहरण देना बेहतर होगा, जिसकी आवश्यकता थी।
— जॉन स्कीट
@JonSkeet मैं वास्तव में अभी मल्टी-लाइन के लिए बहुत अच्छा उपयोग-मामला नहीं सोच सकता, लेकिन मैंने इसके बजाय दोनों मामलों को जोड़ा।
— इपिकपांडेफर्स
2
ईमानदारी से, 'Netbeans 8.0' संस्करण को किसी ने नीचे पोस्ट किया और हटा दिया गया था, जो वास्तव में सच्चाई के करीब था, हालांकि Netbeans ऑलमैन शैली के बयानों के शुरुआती ब्रेसिज़ को ठीक से प्रारूपित नहीं करने के लिए कुख्यात है।
— एपिकपांडफर्सेज
3
मुझे लगता है कि वर्तमान समाधान "लिपटे हुए लाइनों में शामिल नहीं होना" और हाथ से स्वरूपण करने में सक्षम है, लेकिन Ctrl+Alt+Fअगर आप किसी और के कोड को ऑटो-स्वरूपित कर रहे हैं तो दबाने की तुलना में कुछ थकाऊ लगता है ।
— एपिकपांडफर्सेज
और किसी कारणवश एक्लिप्स xमें घुंघराले ब्रेस को खोले बिना और इसे बंद करने के प्रकार का पता लगाने में समस्या हो रही थी , इसलिए मैंने पहले सरल संस्करण के बजाय एक कथन का उपयोग किया।
— एपिकपांडाफर्स 15

जवाबों:

30

बॉक्स से बाहर IntelliJ 13 शायद आपके लिए काम करेगा।

अगर मैं इसे इस तरह लिखता हूं:

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

और फिर ऑटो फॉर्मेटर (कोई परिवर्तन नहीं) लागू करें:

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

आपके सिंगल लाइन स्टेटमेंट के लिए भी यही सही है। यह मेरा अनुभव रहा है कि IntelliJ अपने ऑटो स्वरूपण को कैसे लागू किया जाता है में अधिक लचीला है। इंटेलीज को लाइन रिटर्न को हटाने या जोड़ने की संभावना कम है, अगर आप इसे वहां डालते हैं तो यह मानता है कि आपको इसे वहां रखना है। IntelliJ खुशी से आपके लिए अपने टैब-स्पेस को समायोजित करेगा।

IntelliJ को आपके लिए ऐसा करने के लिए भी कॉन्फ़िगर किया जा सकता है। "सेटिंग" -> "कोड शैली" -> "जावा" के तहत, "रैपिंग और ब्रेसेस" टैब में आप "चेन मेथड कॉल्स" को "हमेशा रैप" करने के लिए सेट कर सकते हैं।

ऑटो-स्वरूपण से पहले 

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

ऑटो-स्वरूपण के बाद 

// 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());
— माइक रायलैंडर
स्रोत
सवाल यह है कि क्या यह इस तरह से इसे स्वचालित रूप से प्रारूपित करने में सक्षम है? यह समस्या को सरल करता है यदि ऑटो-फ़ॉर्मेटिंग उस तरह से प्रारूपित करने के लिए एक अच्छा काम करता है जिस तरह से मैं कोड को स्टाइल करना चाहता हूं, उस तरह से किसी भी कोड को किसी और के कोड को पढ़ना आसान है।
— एपिकपांडाफॉर्ल्स
@Zhuinden मैंने एक लाइन स्टेटमेंट के लिए यह करने के लिए एक उदाहरण के साथ उत्तर को अपडेट किया है। जैसा कि दिखाया गया है कि यह मल्टी-लाइन स्टेटमेंट के लिए कुछ हद तक काम करता है। इंटेलीज के ऑटो-फॉर्मेट को कॉन्फ़िगर करने के लिए कई विकल्प हैं, आप शायद इसे ठीक से प्रदर्शित करने के लिए परिष्कृत कर सकते हैं जैसे कि आपके पास यह प्रश्न है।
— माइक रायलैंडर
मैं ऊपर बताए गए XML के अनुसार चीजें सेट करता हूं, मुझे लगता है कि मैं एंड्रॉइड न होने वाली किसी चीज के लिए ग्रहण के बजाय इंटेलीज का उपयोग करूंगा। धन्यवाद।
— एपिकपांडाफार्स
1
@EpicPandaForce आप Android के लिए भी इसका उपयोग क्यों नहीं करेंगे?
— हरमन
@ हर्मन तकनीकी रूप से मैंने तब से एंड्रॉइड के लिए एंड्रॉइड स्टूडियो का उपयोग करना शुरू कर दिया है। मुझे कुछ अतिरिक्त RAM स्थापित करनी थी, लेकिन फर्म में 8 जीबी के साथ अब कुछ बिछा हुआ था, जिसे संकलित करते समय
— ग्रैडल
59

एकल-पंक्ति कथनों के लिए ग्रहण में:

अपनी परियोजना या वैश्विक प्राथमिकताओं में Java -> Code Style -> Formatter -> Edit -> Line Wrapping -> Function Calls -> Qualified Invocations, सेट पर जाएं Wrap all elements, except first if not necessaryऔर टिक करें Force split, even if line shorter than maximum line width।

— Arend
स्रोत
अरे, यह ठीक प्रतीत होता है, सिवाय इसके कि मैं इंडेंट करने के लिए मजबूर हूं, वह भी या तो डिफ़ॉल्ट इंडेंडेशन या कॉलम के साथ या 1. इससे कोई मतलब नहीं है। मेरा इंडेंटेशन करंट के आधार पर भिन्न होता है। जैसे: अंतिम सूची <DataRow> days = MpedSelect.query ("gameDays", DataRow.class) .param ("सीज़नआईड", 20142015) .select (संदर्भ); ऊपर के लिए मैं चाहता हूं कि अगली 2 पंक्तियां पिछली पंक्ति के बिंदु पर बिल्कुल इंडेंट की जाएं।
— सरवण कुमार एम
1
लगभग आदर्श! :-) कभी-कभी हालांकि यह मेरी प्राथमिकता के लिए बहुत अधिक लपेटता है: .filter(c -> c.getValue().equals(newValue))लंबोदर के भीतर विवरण, उदाहरण के लिए भी असमान से पहले लपेटा जाएगा। यदि कोई ऐसी सेटिंग केवल लैम्ब्डा से संबंधित पद्धति पर लागू होगी, तो अच्छा होगा; मैं देख रहा हूं कि इसे लागू करना मुश्किल हो सकता है ...
— डोमिनिक
24

एक्लिप्स (मंगल) में लैम्बडा एक्सप्रेशन फॉर्मेटर का विकल्प होता है।

के लिए जाओ Window > Preferences > Java > Code Style > Formatter

यहां छवि विवरण दर्ज करें

क्लिक करें Editबटन, पर जाएँ Bracesटैग और सेट Lambda Bodyकरने के लिएNext Line Indented

यहां छवि विवरण दर्ज करें

एक अन्य विकल्प इन गुणों को आपकी परियोजना सेटिंग्स में अद्यतन करता है। ( 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
— डिएगो डी
स्रोत
2
यह केवल ब्रैकेटेड लैम्ब्डा के साथ मदद करता है।
— निक
इन गुणों को अपडेट करने से मदद नहीं मिलती
— Piotr Wittchen
19

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

मैंने अन्य सभी उत्तरों में वर्णित सभी चीजों की कोशिश की और अधिकांश उपयोग मामलों के लिए कोई भी सूट नहीं करता है।
यह कुछ के लिए ठीक हो सकता है लेकिन दूसरों के लिए अप्रिय हो सकता है।

मुझे एक ऐसा रास्ता मिला जो मेरे लिए सबसे ज्यादा सूट करता है।
मैं यह सोचकर इसे साझा करता हूं कि यह दूसरों की मदद कर सकता है।

ध्यान दें कि मेरे रास्ते में एक व्यापार-बंद है: यह स्वीकार करते हुए कि प्रत्येक योग्य आह्वान हमेशा एक अलग रेखा पर होना चाहिए।
यह शायद फॉर्मैटर कॉन्फ़िगरेशन में गुम विकल्प है: 1डिफ़ॉल्ट रूप से मंगलाचरण का उपयोग करने के बजाय लाइन को लपेटने के लिए इनवोकेशन के संदर्भ में सीमा ।

यहाँ मेरे 2 संयुक्त उपकरण हैं इसे सही ढंग से संभालने के लिए:

  • अधिकांश मामलों के लिए कस्टमाइज़िंग ग्रहण फ़ॉर्मेटर कॉन्फ़िगरेशन

  • //@formatter:off ... //@formatter:onकोने के मामलों के लिए एक कोड टेम्पलेट बनाना ।

ग्रहण के सूत्रण विन्यास को अनुकूलित
करना परिवर्तन का मूल्य कैप्चर में लाल रंग से घिरा हुआ है।

चरण 1) अपना खुद का जावा कोड स्टाइल फॉर्मेट बनाएं

Preferencesमेनू और पेड़ में, करने के लिए जाओ Java -> Code Style -> Formatter।
एक नया बनाने के लिए "नया" पर क्लिक करें Profile(इसे "जावा सम्मेलनों के साथ आरंभ करें")।

ग्रहण का सूत्र

अगले दो चरणों को आपके कस्टम फ़ॉर्मेट प्रोफ़ाइल में किया जाना है।

चरण 2) लिपटे लाइनों के लिए इंडेंटेशन कॉन्फ़िगरेशन बदलें

पहचान विन्यास

संशोधन सारणी के बजाय व्हाट्सएप का उपयोग करने की अनुमति देता है।
अगले चरण में यह बात होगी क्योंकि हम कॉलम इंडेंटेशन विकल्प के साथ लाइन रैपिंग पॉलिसी को कॉन्फ़िगर करते हैं।
यह वास्तव में अप्रिय स्थान बनाता है से बचना होगा।

चरण 3) लिपटे लाइनों के लिए डिफ़ॉल्ट इंडेंटेशन और योग्य मंगलाचरण के लिए लाइन रैपिंग पॉलिसी बदलें

लिपटा हुआ लाइन आकार

यहां प्रश्न के कोड के साथ एक परीक्षण प्रारूपण है।

प्रारूपण करने से पहले:

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

स्वरूपण के बाद:

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

//@formatter:off ... //@formatter:onकोने के मामलों के लिए कोड टेम्पलेट बनाना ।

मैन्युअल या कॉपी-पेस्ट लिखना //@formatter:onऔर //@formatter:offठीक है जैसा कि आप इसे शायद ही कभी लिखते हैं।
लेकिन अगर आपको इसे सप्ताह में कई बार लिखना है या दिन के हिसाब से और भी बुरा है, तो अधिक स्वचालित तरीके से आपका स्वागत है।

चरण 1) जावा संपादक टेम्पलेट पर जाएं

Preferencesमेनू और पेड़ में, करने के लिए जाओ Java ->Editor -> Template।
यहां छवि विवरण दर्ज करें

चरण 2) चयनित कोड के लिए स्वरूपण को अक्षम करने के लिए टेम्पलेट बनाएं

टेम्प्लेट फॉर्मेटर ऑन

अब आप इसका परीक्षण कर सकते हैं।
उन पंक्तियों का चयन करें जिन्हें आप स्वरूपण को अक्षम करना चाहते हैं।
अब ctrl+spaceदो बार दर्ज करें (पहले एक "जावा प्रस्ताव" है और दूसरा "टेम्पलेट प्रस्ताव" है)।
आपको कुछ मिलना चाहिए:

टेम्पलेट का प्रस्ताव

fmtस्क्रीनशॉट के रूप में टेम्पलेट का चयन करें और "एन्टर" पर क्लिक करें। किया हुआ!

टेम्पलेट आवेदन के बाद परिणाम

— davidxxx
स्रोत
16

मैं फ़ंक्शन के बाद खाली टिप्पणी "//" जोड़कर सिंगल-लाइन स्टेटमेंट प्रारूपित करता हूं।

List<Integer> list = Arrays.stream(x) //
                           .filter((n) -> n % 2 == 0) //
                           .map((n) -> n * 4) //
                           .boxed() //
                           .collect(Collectors.toList());
— Saljack
स्रोत
3
आसान और प्रभावी।
— स्टीव
12
मुझे लगता है कि यह आईडीई शैली विन्यास स्थापित नहीं करने के लिए आपके कोडबेस में शोर है। यह पहली बार आपके कोडबेस को देखने वाले लोगों के लिए भ्रामक हो सकता है।
— मार्क बौविएर
9

आदर्श नहीं है, लेकिन आप सिर्फ उन वर्गों के लिए फॉर्मेटर को बंद कर सकते हैं जो थोड़े घने हैं। उदाहरण के लिए

  //@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

"विंडो> प्राथमिकताएं> जावा> कोड शैली> प्रारूपक" पर जाएं। "संपादित करें ..." बटन पर क्लिक करें, "बंद / पर टैग" टैब पर जाएं और टैग को सक्षम करें।

— throp
स्रोत
3
यह मेरा स्वरूपण सही पाने के लिए एक ungeeky लेकिन सरल विकल्प लग रहा था
— एसएमसी
2

मेरे लिए काम करने वाला Never join already wrapped linesविकल्प प्राथमिकता में फ़ॉर्मेटर के लाइन रैपिंग अनुभाग में विकल्प को टिक कर रहा था ।

— Nosrep
स्रोत
1

यदि आपके पास पहले से कस्टम ग्रहण सूत्र नहीं है:

ग्रहण की प्राथमिकताएँ जावा> कोड शैली> नया स्वरूप एक नाम दर्ज करें ठीक नियंत्रण रेखा विराम पर क्लिक करें

प्रोफ़ाइल लाइन रैपिंग टैब संपादित करें चेक करें "कभी भी पहले से लिपटी लाइनों में शामिल न हों"

यह ऐसे ही खत्म हो जाएगा

    String phrase = employeeList
            .stream()
            .filter(p -> p.getAge() >= 33)
            .map(p -> p.getFirstName())
            .collect(Collectors.joining(" and ", "In Germany ", " are of legal age."));

हर टाइप करने की जरूरत है। अगली पंक्ति में शुरू करें

क्रेडिट - https://www.selikoff.net/2017/07/02/eclipse-and-line-wrapping/

— Somendu
स्रोत
-1

एक्लिप्स के नवीनतम संस्करण में एक अंतर्निहित फॉर्मेटर जावा 8 प्रारूपण, गोटो है

Preferences -> Java -> Code Style -> Formatter -> Active profile

and Select Eclipse 2.1[built-in] profile
— युवराज चितेला
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.