Java Lambda Stream Distinct() на произвольном ключе?

Ответ 1

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

/**
 * Stateful filter. T is type of stream element, K is type of extracted key.
 */
static class DistinctByKey<T,K> {
    Map<K,Boolean> seen = new ConcurrentHashMap<>();
    Function<T,K> keyExtractor;
    public DistinctByKey(Function<T,K> ke) {
        this.keyExtractor = ke;
    }
    public boolean filter(T t) {
        return seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
}

Я не знаю ваших классов домена, но я думаю, что с этим вспомогательным классом вы могли бы сделать то, что хотите:

BigDecimal totalShare = orders.stream()
    .filter(new DistinctByKey<Order,CompanyId>(o -> o.getCompany().getId())::filter)
    .map(Order::getShare)
    .reduce(BigDecimal.ZERO, BigDecimal::add);

К сожалению, вывод типа не мог получить достаточно много внутри выражения, поэтому мне пришлось явно указать аргументы типа для класса DistinctByKey.

Это требует большей настройки, чем подход коллекционеров описанный Луи Вассерманом, но это имеет то преимущество, что отдельные предметы проходят сразу же, а не буферизуются до тех пор, пока сбор не завершится, Пространство должно быть таким же, как (неизбежно) оба подхода в конечном итоге накапливают все различные ключи, извлеченные из элементов потока.

UPDATE

Можно избавиться от параметра типа K, поскольку он фактически не используется для чего-либо, кроме сохранения на карте. Таким образом, Object достаточно.

/**
 * Stateful filter. T is type of stream element.
 */
static class DistinctByKey<T> {
    Map<Object,Boolean> seen = new ConcurrentHashMap<>();
    Function<T,Object> keyExtractor;
    public DistinctByKey(Function<T,Object> ke) {
        this.keyExtractor = ke;
    }
    public boolean filter(T t) {
        return seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
}

BigDecimal totalShare = orders.stream()
    .filter(new DistinctByKey<Order>(o -> o.getCompany().getId())::filter)
    .map(Order::getShare)
    .reduce(BigDecimal.ZERO, BigDecimal::add);

Это немного упрощает, но мне еще нужно указать аргумент типа для конструктора. Попытка использовать алмаз или статический метод factory, похоже, не улучшает ситуацию. Я думаю, что сложность заключается в том, что компилятор не может вызывать общие параметры типа - для конструктора или вызова статического метода - когда либо находится в выражении экземпляра ссылки метода. О, хорошо.

(Другой вариант этого, который, вероятно, упростит это, состоит в том, чтобы сделать DistinctByKey<T> implements Predicate<T> и переименовать метод в eval. Это устранит необходимость использования ссылки на метод и, вероятно, улучшит вывод типа. так же хорошо, как и решение ниже.)

ОБНОВЛЕНИЕ 2

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

public static <T> Predicate<T> distinctByKey(Function<? super T,Object> keyExtractor) {
    Map<Object,Boolean> seen = new ConcurrentHashMap<>();
    return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}

BigDecimal totalShare = orders.stream()
    .filter(distinctByKey(o -> o.getCompany().getId()))
    .map(Order::getShare)
    .reduce(BigDecimal.ZERO, BigDecimal::add);

Ответ 2

Вы более или менее должны сделать что-то вроде

 elements.stream()
    .collect(Collectors.toMap(
        obj -> extractKey(obj), 
        obj -> obj, 
       (first, second) -> first
           // pick the first if multiple values have the same key
       )).values().stream();

Ответ 3

Вариант второго обновления Стюарта Маркса. Использование набора.

public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
    Set<Object> seen = Collections.newSetFromMap(new ConcurrentHashMap<>());
    return t -> seen.add(keyExtractor.apply(t));
}

Ответ 4

Мы также можем использовать RxJava (очень мощную реактивную библиотеку расширений)

Observable.from(persons).distinct(Person::getName)

или же

Observable.from(persons).distinct(p -> p.getName())

Ответ 5

Чтобы ответить на ваш вопрос во втором обновлении:

Единственная часть, которую я пытаюсь выяснить, заключается в том, как ConcurrentHashMap поддерживает только один экземпляр для всего потока:

public static <T> Predicate<T> distinctByKey(Function<? super T,Object> keyExtractor) {
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

В вашем примере кода distinctByKey вызывается только один раз, поэтому ConcurrentHashMap создается только один раз. Вот объяснение:

Функция distinctByKey - это просто старая функция, возвращающая объект, и этот объект оказывается предикатом. Имейте в виду, что предикат - это в основном фрагмент кода, который можно оценить позже. Чтобы вручную оценить предикат, вы должны вызвать метод в Predicate interface, например test. Итак, предикат

t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null

- это просто объявление, которое фактически не оценивается внутри distinctByKey.

Предикат передается как любой другой объект. Он возвращается и передается в операцию filter, которая в основном оценивает предикат несколько раз по отношению к каждому элементу потока, вызывая test.

Я уверен, что filter сложнее, чем я это делал, но дело в том, что предикат оценивается много раз за пределами distinctByKey. Нет ничего особенного * о distinctByKey; это просто функция, которую вы вызывали один раз, поэтому ConcurrentHashMap создается только один раз.

* Помимо хорошо сделанных, @stuart-marks:)

Ответ 6

Вы можете использовать метод distinct(HashingStrategy) в Eclipse Collections.

List<String> list = Lists.mutable.with("ABQ", "ALB", "CHI", "CUN", "PHX", "PUJ", "BWI");
ListIterate.distinct(list, HashingStrategies.fromFunction(s -> s.substring(0, 1)))
    .each(System.out::println);

Если вы можете реорганизовать list для реализации интерфейса Eclipse Collections, вы можете вызвать метод непосредственно в списке.

MutableList<String> list = Lists.mutable.with("ABQ", "ALB", "CHI", "CUN", "PHX", "PUJ", "BWI");
list.distinct(HashingStrategies.fromFunction(s -> s.substring(0, 1)))
    .each(System.out::println);

HashingStrategy - это просто интерфейс стратегии, который позволяет вам определять пользовательские реализации equals и hashcode.

public interface HashingStrategy<E>
{
    int computeHashCode(E object);
    boolean equals(E object1, E object2);
}

Примечание. Я являюсь коммиттером для коллекций Eclipse.

Ответ 7

Другой способ поиска отдельных элементов

List<String> uniqueObjects = ImmutableList.of("ABQ","ALB","CHI","CUN","PHX","PUJ","BWI")
            .stream()
            .collect(Collectors.groupingBy((p)->p.substring(0,1))) //expression 
            .values()
            .stream()
            .flatMap(e->e.stream().limit(1))
            .collect(Collectors.toList());

Ответ 8

Можно сделать что-то вроде

Set<String> distinctCompany = orders.stream()
        .map(Order::getCompany)
        .collect(Collectors.toSet());

Ответ 9

Set.add(element) возвращает true, если в наборе еще не было element, иначе false. Таким образом, вы можете сделать это.

Set<String> set = new HashSet<>();
BigDecimal totalShare = orders.stream()
    .filter(c -> set.add(c.getCompany().getId()))
    .map(c -> c.getShare())
    .reduce(BigDecimal.ZERO, BigDecimal::add);

Если вы хотите сделать это параллельно, вы должны использовать параллельную карту.