Java 8: форматирование лямбда с новыми строками и отступами

Из коробки 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 с радостью настроит для вас пространство вкладок.

IntelliJ также можно настроить, чтобы сделать некоторые из этих действий за вас. В разделе «Настройки» -> «стиль кода» -> «java» на вкладке «Обертка и фигурные скобки» вы можете установить «вызовы цепных методов» на «всегда перенос».

Перед автоматическим форматированием

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

В Eclipse для однострочных операторов:

В вашем проекте или глобальных настройках перейдите к 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.

Eclipse (Mars) имеет возможность форматирования лямбда-выражений.

Go to 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

Этот вопрос устарел, и, к сожалению, стандартная конфигурация средства форматирования Eclipse по-прежнему неудобна для написания функционального кода в удобочитаемом виде.

Я пробовал все, что упоминалось во всех других ответах, и ни один из них не подходит для большинства случаев использования.
Это может быть хорошо для некоторых, но неприятно для других.

Я нашел способ, который подходит мне больше всего.
Я делюсь им, думая, что он может помочь другим.

Обратите внимание, что у моего пути есть компромисс: принятие того, что каждый квалифицированный вызов всегда должен находиться в отдельной строке.
Возможно, это отсутствующая опция в конфигурации средства форматирования: указание порога с точки зрения вызовов для переноса строки вместо использования 1 вызов по умолчанию.

Вот мои 2 комбинированных инструмента, чтобы справиться с этим довольно правильно:

• Настройка конфигурации средства форматирования Eclipse для большинства случаев

• Создание шаблона кода с //@formatter:off ... //@formatter:on для крайних случаев.

Настройка конфигурации средства форматирования Eclipse
Значение, которое нужно изменить, обведено красным в захвате.

Шаг 1) Создайте собственный форматировщик стиля кода Java

Preferences и в дереве перейдите к Java -> Code Style -> Formatter.
Нажмите "Создать", чтобы создать новый Profile (инициализируйте его с помощью "Соглашений Java").

Следующие два шага необходимо выполнить в пользовательском профиле средства форматирования.

Шаг 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) Перейдите к шаблону редактора Java

Preferences и в дереве перейдите к Java ->Editor -> Template.

Шаг 2) Создайте шаблон, чтобы отключить форматирование для выбранного кода

Теперь вы можете протестировать его.
Выберите строки, для которых вы хотите отключить форматирование.
Теперь дважды введите ctrl+space (первый – "Предложения Java", второй – "Предложения шаблона").
Вы должны получить что-то вроде:

Выберите шаблон fmt как на скриншоте и нажмите «Войти». Готово!

Я форматирую однострочный оператор, добавляя пустой комментарий "//" после functions.

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

Не идеально, но вы можете отключить форматирование только для тех разделов, которые немного плотные. Например

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

Перейдите в «Окно»> «Настройки»> «Java»> «Стиль кода»> «Форматтер». Нажмите кнопку "Редактировать...", перейдите на вкладку "Выкл./Вкл. теги" и включите теги.

Вариант, который работал у меня, заключался в том, чтобы отметить параметр Never join already wrapped lines в разделе «Перенос строк» ​​модуля форматирования в настройках.

Если у вас еще нет пользовательского средства форматирования Eclipse:

Настройки Eclipse Java › Стиль кода › Formatter New Введите имя Нажмите «ОК» Управление разрывами строк

Отредактируйте вкладку «Перенос строк» ​​в профиле. Установите флажок «Никогда не соединять уже перенесенные строки».

Это закончится так

    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/