Java 8: Định dạng lambda với dòng mới và thụt lề


82

Những gì tôi muốn đạt được với thụt lề lambda là như sau:

Câu lệnh nhiều dòng:

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

Câu lệnh một dòng:

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



Hiện tại, Eclipse đang tự động định dạng như sau:

Câu lệnh nhiều dòng:

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

Câu lệnh một dòng:

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

Và tôi thấy điều này thực sự lộn xộn, bởi vì cách collectgọi nằm ngay bên dưới returnvà không có khoảng trống nào ở giữa. Tôi sẽ thích nó hơn nếu tôi có thể bắt đầu lambda trong một dòng mới được thụt lề và để lệnh .filter(gọi sẽ ở ngay phía trên lệnh .collect(gọi. Tuy nhiên, thứ duy nhất có thể được tùy chỉnh với Java-8 Eclipse Formatter tiêu chuẩn là ()dấu ngoặc nhọn ở đầu thân lambda, nhưng không có gì cho dấu ngoặc trước đó, cũng không phải thụt lề.

Và trong trường hợp gọi một dòng, nó chỉ sử dụng đường bọc cơ bản và làm cho nó trở thành một chuỗi hỗn độn. Tôi không nghĩ rằng tôi cần giải thích lý do tại sao điều này khó giải mã sau đó.

Có cách nào để tùy chỉnh định dạng nhiều hơn và đạt được kiểu định dạng đầu tiên trong Eclipse không? (Hoặc, tùy chọn, trong IDE khác như IntelliJ IDEA.)



CHỈNH SỬA: Phiên bản gần nhất mà tôi có thể nhận được là với IntelliJ IDEA 13 Community Edition (đọc: phiên bản miễn phí: P) như sau (được xác định bằng cách thụt lề liên tục, trong trường hợp này là 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);    

Nó cũng cho phép "căn chỉnh" lệnh gọi phương thức chuỗi như thế này:

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

Cá nhân tôi thấy rằng mặc dù nó có ý nghĩa hơn, nhưng phiên bản thứ hai đẩy nó đi quá xa, vì vậy tôi thích phiên bản đầu tiên hơn.

Thiết lập chịu trách nhiệm cho thiết lập đầu tiên như sau:

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

Tôi đã cố gắng đảm bảo mọi thứ đều hợp lý, nhưng tôi có thể đã làm sai một thứ gì đó, vì vậy nó có thể cần những điều chỉnh nhỏ.

Nếu bạn là người Hungary như tôi và bạn đang sử dụng bố cục Hungary, thì sơ đồ bàn phím này có thể hữu ích cho bạn, để bạn không thể sử dụng AltGR + F, AltGR + G, AltGR + B , AltGR + N và AltGR + M (tương ứng với 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>

Mặc dù IntelliJ dường như không cung cấp cách đặt dấu ngoặc nhọn mở của lambda vào một dòng mới, nhưng đó là một cách định dạng khá hợp lý, vì vậy tôi sẽ đánh dấu điều này là được chấp nhận.


10
Bạn không thể sử dụng .filter(x -> x.contains("(M)"))? Đơn giản hơn nhiều ... Nếu bạn thực sự đang nói về những nơi bạn cần nhiều câu lệnh, thì tốt hơn là bạn nên đưa ra một ví dụ cần nó.
Jon Skeet,

@JonSkeet Tôi thực sự không thể nghĩ ra một trường hợp sử dụng thực sự tốt cho nhiều dòng ngay bây giờ, nhưng tôi đã thêm cả hai trường hợp thay thế.
EpicPandaForce

2
Thành thật mà nói, phiên bản 'Netbeans 8.0' mà ai đó đã đăng và xóa bên dưới thực sự gần với sự thật, mặc dù Netbeans nổi tiếng là không cho phép định dạng đúng dấu ngoặc nhọn của câu lệnh theo kiểu Allman.
EpicPandaForce

3
Tôi đoán giải pháp hiện tại là bật "không bao giờ nối các dòng được bọc" và định dạng bằng tay, nhưng điều đó có vẻ hơi tẻ nhạt so với việc nhấn Ctrl+Alt+Fnếu bạn đang tự động định dạng mã của người khác.
EpicPandaForce

Và vì lý do nào đó Eclipse gặp vấn đề với việc tìm ra kiểu xmà không cần mở dấu ngoặc nhọn và đóng nó, do đó tại sao lúc đầu tôi sử dụng một câu lệnh thay vì phiên bản đơn giản.
EpicPandaForce

Câu trả lời:


29

Ngoài ra, IntelliJ 13 có thể sẽ phù hợp với bạn.

Nếu tôi viết nó theo cách này:

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

Và sau đó áp dụng trình định dạng tự động (không có thay đổi):

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

Điều này cũng đúng với câu lệnh một dòng của bạn. Theo kinh nghiệm của tôi, IntelliJ linh hoạt hơn trong cách áp dụng định dạng tự động của nó. IntelliJ ít có khả năng xóa hoặc thêm trả về dòng, nếu bạn đặt nó ở đó thì nó cho rằng bạn muốn đặt nó ở đó. IntelliJ sẽ vui vẻ điều chỉnh không gian tab cho bạn.


IntelliJ cũng có thể được cấu hình để thực hiện một số việc này cho bạn. Trong "cài đặt" -> "kiểu mã" -> "java", trong tab "Bao bọc và dấu ngoặc nhọn", bạn có thể đặt "lệnh gọi phương thức chuỗi" thành "luôn quấn".

Trước khi tự động định dạng

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

Sau khi tự động định dạng

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

Câu hỏi đặt ra là nó có khả năng tự động định dạng theo cách này không? Nó đơn giản hóa vấn đề nếu tính năng tự động định dạng thực hiện tốt công việc định dạng nó theo cách tôi muốn tạo kiểu mã, theo cách đó, bất kỳ mã nào cũng dễ đọc hơn ngay cả mã của bất kỳ ai khác.
EpicPandaForce

@Zhuinden Tôi đã cập nhật câu trả lời với một ví dụ về cách thực hiện điều này cho một câu lệnh một dòng. Như được hiển thị, nó cũng hoạt động ở một mức độ nào đó đối với câu lệnh nhiều dòng. Có nhiều tùy chọn để định cấu hình bộ định dạng tự động của IntelliJ, bạn có thể tinh chỉnh nó để xuất hiện chính xác như bạn có trong câu hỏi.
Mike Rylander,

Tôi thiết lập mọi thứ theo XML mà tôi đã dán ở trên, tôi đoán tôi sẽ sử dụng IntelliJ thay vì Eclipse cho bất kỳ thứ gì không phải là Android. Cảm ơn.
EpicPandaForce

1
@EpicPandaForce tại sao bạn không sử dụng nó cho Android?
herman

@herman về mặt kỹ thuật, tôi cũng đã bắt đầu sử dụng Android Studio cho Android kể từ đó. Tôi đã cài đặt một vài gigs thêm RAM, nhưng công ty đã có một số đặt xung quanh vì vậy bây giờ với 8 GB, Gradle không đóng băng toàn bộ máy tính trong khi nó đang biên soạn: P
EpicPandaForce

59

Trong Eclipse, đối với các câu lệnh một dòng:

Trong tùy chọn dự án hoặc toàn cầu của bạn, hãy chuyển đến Java -> Code Style -> Formatter -> Edit -> Line Wrapping -> Function Calls -> Qualified Invocations, đặt Wrap all elements, except first if not necessaryvà đánh dấu Force split, even if line shorter than maximum line width.


Này, điều này có vẻ ổn, ngoại trừ, tôi buộc phải thụt lề, điều đó cũng với dấu nợ hoặc cột mặc định hoặc 1. Điều đó không có ý nghĩa. Thụt lề của tôi khác nhau dựa trên hiện tại. Ví dụ: final List <DataRow> days = MappedSelect.query ("gameDays", DataRow.class) .param ("seasonId", 20142015) .select (context); Đối với phần trên, tôi muốn 2 dòng tiếp theo được thụt vào chính xác trên dấu chấm dòng trước đó.
Saravana Kumar M

1
Gân như hoan hảo! :-) Tuy nhiên, đôi khi nó bao bọc quá nhiều so với sở thích của tôi: Các câu lệnh trong lambda, ví dụ: .filter(c -> c.getValue().equals(newValue))cũng sẽ được bao bọc ngay trước .equals. Sẽ rất tuyệt nếu một thiết lập như vậy chỉ áp dụng cho phương thức liên quan đến lambda; Tôi thấy rằng điều này có thể khó thực hiện mặc dù ...
Dominic

24

Eclipse (Mars) có một tùy chọn cho trình định dạng biểu thức lambda.

Đi đến Window > Preferences > Java > Code Style > Formatter

nhập mô tả hình ảnh ở đây

Nhấp vào Editnút, chuyển đến BracesThẻ và đặt Lambda BodythànhNext Line Indented

nhập mô tả hình ảnh ở đây

Một tùy chọn khác là cập nhật các thuộc tính này vào cài đặt dự án của bạn. ( 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
điều này dường như chỉ hữu ích với lambdas trong ngoặc đơn.
Nick

cập nhật các thuộc tính này không giúp được gì
Piotr Wittchen

19

Câu hỏi này hiện đã cũ và thật không may, cấu hình mặc định của trình định dạng Eclipse vẫn không thân thiện với người dùng để viết mã chức năng theo cách có thể đọc được.

Tôi đã thử tất cả những thứ được đề cập trong tất cả các câu trả lời khác và không có câu nào phù hợp với hầu hết các trường hợp sử dụng.
Nó có thể ổn đối với một số người nhưng khó chịu đối với những người khác.

Tôi đã tìm thấy một cách phù hợp với tôi trong hầu hết thời gian.
Tôi chia sẻ nó bằng cách nghĩ rằng nó có thể giúp ích cho người khác.

Lưu ý rằng cách của tôi có một sự đánh đổi: chấp nhận rằng mỗi lời gọi đủ điều kiện luôn nằm trên một dòng riêng biệt.
Nó có thể là tùy chọn bị thiếu trong cấu hình định dạng: chỉ ra ngưỡng về các lời gọi để bọc dòng thay vì sử dụng 1lời gọi theo mặc định.

Đây là 2 công cụ kết hợp của tôi để xử lý nó một cách chính xác:

  • Tùy chỉnh cấu hình bộ định dạng Eclipse cho hầu hết các trường hợp

  • Tạo một mẫu mã với //@formatter:off ... //@formatter:oncác trường hợp góc.


Tùy chỉnh cấu hình bộ định dạng Eclipse
Giá trị cần thay đổi được bao quanh bằng màu đỏ trong ảnh chụp.

Bước 1) Tạo bộ định dạng kiểu mã Java của riêng bạn

Preferencesvà trong cây, đi tới Java -> Code Style -> Formatter.
Nhấp vào "Mới" để tạo mới Profile(khởi tạo nó bằng "quy ước Java").

Bộ định dạng Eclipse

Hai bước tiếp theo phải được thực hiện trong hồ sơ bộ định dạng tùy chỉnh của bạn.

Bước 2) Thay đổi cấu hình thụt lề cho các dòng được bọc

Cấu hình nhận dạng

Việc sửa đổi cho phép sử dụng khoảng trắng thay vì lập bảng.
Nó sẽ quan trọng trong bước tiếp theo khi chúng ta định cấu hình chính sách gói dòng với tùy chọn thụt lề cột.
Nó sẽ tránh thực sự tạo ra không gian khó chịu.

Bước 3) Thay đổi thụt lề mặc định cho các dòng được bao bọc và chính sách bao bọc dòng cho lệnh gọi đủ điều kiện

Kích thước dòng bao bọc


Đây là một định dạng kiểm tra với mã của câu hỏi.

Trước khi định dạng:

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

Sau khi định dạng:

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

Tạo các mẫu mã //@formatter:off ... //@formatter:oncho các trường hợp góc.

Viết thủ công hoặc sao chép-dán //@formatter:on//@formatter:offcũng tốt vì bạn hiếm khi viết.
Nhưng nếu bạn phải viết nó nhiều lần theo tuần hoặc thậm chí tệ hơn theo ngày, thì một cách tự động hơn được hoan nghênh.

Bước 1) Đi tới mẫu Java Editor

Preferencesvà trong cây, đi tới Java ->Editor -> Template.
nhập mô tả hình ảnh ở đây

Bước 2) Tạo mẫu để tắt định dạng cho mã đã chọn

Tắt định dạng mẫu

Bây giờ bạn có thể kiểm tra nó.
Chọn dòng mà bạn muốn tắt định dạng.
Bây giờ hãy nhập ctrl+spacehai lần (lần đầu tiên là "đề xuất Java" và lần thứ hai là "đề xuất mẫu").
Bạn sẽ nhận được một cái gì đó như:

đề xuất mẫu

Chọn fmtmẫu như trong ảnh chụp màn hình và nhấp vào "Enter". Làm xong!

kết quả sau khi ứng dụng mẫu


16

Tôi định dạng câu lệnh một dòng bằng cách thêm chú thích trống "//" sau các hàm.

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

3
Dễ dàng và hiệu quả.
Steve

12
Tôi nghĩ rằng đó là tiếng ồn trong cơ sở mã của bạn chỉ vì không đặt cấu hình kiểu IDE. Nó có thể gây nhầm lẫn cho những người nhìn vào codebase của bạn lần đầu tiên.
Marc Bouvier

9

Không lý tưởng, nhưng bạn có thể tắt bộ định dạng chỉ cho những phần dày đặc một chút. Ví dụ

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

Đi tới "Window> Preferences> Java> Code Style> Formatter". Nhấp vào nút "Chỉnh sửa ...", chuyển đến tab "Tắt / Bật Thẻ" và bật các thẻ.


3
Đây có vẻ là một tùy chọn khéo léo nhưng đơn giản hơn để giúp định dạng của tôi chính xác
smc 17/03/15

2

Tùy chọn phù hợp với tôi là đánh dấu vào Never join already wrapped linestùy chọn trong phần Line Wrapping của Formatter in Preferences.


1

Nếu bạn chưa có trình định dạng Eclipse tùy chỉnh:

Tùy chọn Eclipse Java> Kiểu mã> Định dạng mới Nhập tên Bấm ok Điều khiển ngắt dòng

Chỉnh sửa cấu hình Tab gói dòng Chọn “Không bao giờ nối các dòng đã được bọc”

Nó sẽ kết thúc như thế này

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

Cần phải gõ mọi. bắt đầu ở dòng tiếp theo

tín dụng - https://www.selikoff.net/2017/07/02/eclipse-and-line-wrapping/


-1

Phiên bản mới nhất của Eclipse có định dạng java 8 trình định dạng được tích hợp sẵn, goto

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

and Select Eclipse 2.1[built-in] profile
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.