Как присоединиться к двум необязательным <String> с разделителем в Java 8
У меня две строки Optional
, name1
и name2
. Я хочу присоединиться к двум таким образом, чтобы результат также был необязательным:
- Если один из них не является пустым, результатом должно быть непустое имя.
- Если оба значения не являются пустыми, я хочу, чтобы результат был связан с разделителем
AND
.
- Если оба пустые, результат должен быть пустым
Optional
Моя попытка:
StringBuilder sb = new StringBuilder();
name1.ifPresent(sb::append);
name2.ifPresent(s -> {
if (sb.length() > 0) {
sb.append(" AND ");
}
sb.append(s);
}
Optional<String> joinedOpt = Optional.ofNullable(Strings.emptyToNull(sb.toString()));
Это работает, но кажется уродливым и не очень функциональным.
PS: Существует аналогичный вопрос, но принятый ответ неверен. В частности, если name1
пуст, а name2
- нет, он возвращает пустой необязательный.
Ответы
Ответ 1
Одним из решений является поток и reduce()
:
Optional<String> joinedOpt = Stream.of(name1, name2)
.filter(Optional::isPresent)
.map(Optional::get)
.reduce((a, b) -> a + " AND " + b);
Не стесняйтесь заменить комбинацию фильтра/карты с Java 9 или Guava, как предложили другие.
Ответ 2
Возможное решение в Java 1.9 было бы
Optional<String> name1 = Optional.of("x");
Optional<String> name2 = Optional.of("y");
String s = Stream.concat(name1.stream(), name2.stream()).collect(Collectors.joining(" AND "));
System.out.println(s);
С Java 1.8 нет способа переходить от опции Необязательно к потоку. Однако вы можете легко добавить такое преобразование в Java 1.8.
static <T> Stream<T> of(Optional<T> option) {
return option.map(Stream::of).orElseGet(Stream::empty);
}
И теперь вы можете использовать метод of
, чтобы объединить оба потока.
Теперь, чтобы получить Необязательный, пустой, если нет результата, вы можете обернуть результат в Необязательный и сделать простой фильтр.
Optional<String> result = Optional.of(collect).filter(s -> !s.isEmpty());
Ответ 3
Немного отличающийся аромат с использованием Collectors.joining
:
Optional<String> result = Optional.of(
Stream.of(so1, so2)
.filter(Optional::isPresent)
.map(Optional::get)
.collect( Collectors.joining(" AND ") )
).filter( s -> !s.isEmpty() );
Что мне нравится в Collectors.joining
, так это то, что потоки Java могут потенциально повторно использовать один класс StringBuilder вместо создания нового при выполнении операции +
.
Ответ 4
Иногда попытка работать с Optional
(или Stream
) просто затушевывает то, что вы пытаетесь выразить в своем коде.
Для меня главная идея здесь в том, что если оба значения присутствуют, они должны быть объединены с " AND ". Вот попытка сосредоточиться на этом:
Optional<String> joinedOpt;
if (name1.isPresent() && name2.isPresent()) {
joinedOpt = Optional.of(name1.get() + " AND " + name2.get());
} else {
joinedOpt = name1.isPresent() ? name1 : name2;
}
Я мог бы неправильно истолковать его сообщение, но этот подход был вдохновлен ответом Стюарта Маркса на аналогичный вопрос, который он более подробно рассмотрел в его рассказ Devoxx о выборе, который он сделал, помогая проекту Optional
.
Ответ 5
Близко к принятому ответу
Optional<String> joinedOpt = Stream.of(name1, name2)
.flatMap(x -> x.map(Stream::of).orElse(null))
.reduce((a, b) -> a + " AND " + b);
Или в java-9:
Optional<String> joinedOpt = Stream.of(name1, name2)
.flatMap(Optional::stream)
.reduce((a, b) -> a + " AND " + b);
Ответ 6
Вот потоковое решение, которое фильтрует те Optional
, которые присутствуют, затем извлекает элементы и использует встроенный Collector для объединения остальных элементов. Затем он проверяет, является ли результат пустым в конце, чтобы вернуть пустой Optional
.
Он принимает List
of Optional
, поэтому он охватывает более общий случай, чем только два элемента.
public Optional<String> optionalJoin(List<Optional<String>> strings) {
String result = strings.stream()
.filter(Optional::isPresent)
.map(Optional::get)
.collect(Collectors.joining(" AND "));
return result.isEmpty() ? Optional.empty() : Optional.of(result);
}
Ответ 7
Однострочный без потоков, но не особенно элегантный:
public static Optional<String> concat(Optional<String> name1, Optional<String> name2) {
return Optional.ofNullable(name1.map(s1 -> name2.map(s2 -> s1 + " AND " + s2).orElse(s1)).orElse(name2.orElse(null)));
}
public static void main(String[] args) {
System.out.println(concat(Optional.of("A"), Optional.of("B")));
System.out.println(concat(Optional.of("A"), Optional.empty()));
System.out.println(concat(Optional.empty(), Optional.of("B")));
System.out.println(concat(Optional.empty(), Optional.empty()));
}