Java 8 Distinto por propriedade

No Java 8, como filtrar uma coleção usando o método Stream API, verificando a distinção de uma propriedade de cada objeto?

Por exemplo, tenho uma lista de Personobjetos e desejo remover pessoas com o mesmo nome,

persons.stream().distinct();

Usarei a verificação de igualdade padrão para um Personobjeto, então preciso de algo como,

persons.stream().distinct(p -> p.getName());

Infelizmente, o distinct()método não possui essa sobrecarga. Sem modificar a verificação de igualdade dentro da Personclasse, é possível fazer isso de forma sucinta?

Considere distinctser um filtro com estado . Aqui está uma função que retorna um predicado que mantém o estado sobre o que foi visto anteriormente e que retorna se o elemento fornecido foi visto pela primeira vez:

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

Então você pode escrever:

persons.stream().filter(distinctByKey(Person::getName))

Observe que, se o fluxo for ordenado e executado em paralelo, isso preservará um elemento arbitrário dentre as duplicatas, em vez da primeira, como o distinct()faz.

(Isso é essencialmente o mesmo que a minha resposta a esta pergunta: Java Lambda Stream Distinct () na chave arbitrária? )

Uma alternativa seria colocar as pessoas em um mapa usando o nome como chave:

persons.collect(Collectors.toMap(Person::getName, p -> p, (p, q) -> p)).values();

Observe que a Pessoa mantida, no caso de um nome duplicado, será o primeiro a ser convocado.

Você pode agrupar os objetos da pessoa em outra classe, que compara apenas os nomes das pessoas. Depois, você desembrulha os objetos quebrados para que uma pessoa seja transmitida novamente. As operações de fluxo podem ter a seguinte aparência:

persons.stream()
    .map(Wrapper::new)
    .distinct()
    .map(Wrapper::unwrap)
    ...;

A classe Wrapperpode ter a seguinte aparência:

class Wrapper {
    private final Person person;
    public Wrapper(Person person) {
        this.person = person;
    }
    public Person unwrap() {
        return person;
    }
    public boolean equals(Object other) {
        if (other instanceof Wrapper) {
            return ((Wrapper) other).person.getName().equals(person.getName());
        } else {
            return false;
        }
    }
    public int hashCode() {
        return person.getName().hashCode();
    }
}

Outra solução, usando Set. Pode não ser a solução ideal, mas funciona

Set<String> set = new HashSet<>(persons.size());
persons.stream().filter(p -> set.add(p.getName())).collect(Collectors.toList());

Ou, se você pode modificar a lista original, pode usar o método removeIf

persons.removeIf(p -> !set.add(p.getName()));

Há uma abordagem mais simples usando um TreeSet com um comparador personalizado.

persons.stream()
    .collect(Collectors.toCollection(
      () -> new TreeSet<Person>((p1, p2) -> p1.getName().compareTo(p2.getName())) 
));

Também podemos usar o RxJava ( biblioteca de extensão reativa muito poderosa )

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

ou

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

Você pode usar o groupingBycoletor:

persons.collect(Collectors.groupingBy(p -> p.getName())).values().forEach(t -> System.out.println(t.get(0).getId()));

Se você quiser ter outro fluxo, use:

persons.collect(Collectors.groupingBy(p -> p.getName())).values().stream().map(l -> (l.get(0)));

Você pode usar o distinct(HashingStrategy)método nas Coleções Eclipse .

List<Person> persons = ...;
MutableList<Person> distinct =
    ListIterate.distinct(persons, HashingStrategies.fromFunction(Person::getName));

Se você puder refatorar personspara implementar uma interface de Coleções do Eclipse, poderá chamar o método diretamente na lista.

MutableList<Person> persons = ...;
MutableList<Person> distinct =
    persons.distinct(HashingStrategies.fromFunction(Person::getName));

HashingStrategy é simplesmente uma interface de estratégia que permite definir implementações personalizadas de iguais e hashcode.

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

Nota: Sou um colaborador das Coleções Eclipse.

Eu recomendo usar o Vavr , se você puder. Com esta biblioteca, você pode fazer o seguinte:

io.vavr.collection.List.ofAll(persons)
                       .distinctBy(Person::getName)
                       .toJavaSet() // or any another Java 8 Collection

Você pode usar a biblioteca StreamEx :

StreamEx.of(persons)
        .distinct(Person::getName)
        .toList()

Estendendo a resposta de Stuart Marks, isso pode ser feito de maneira mais curta e sem um mapa simultâneo (se você não precisar de fluxos paralelos):

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

Então ligue:

persons.stream().filter(distinctByKey(p -> p.getName());

Abordagem semelhante que Saeed Zarinfam usou, mas com mais estilo Java 8 :)

persons.collect(Collectors.groupingBy(p -> p.getName())).values().stream()
 .map(plans -> plans.stream().findFirst().get())
 .collect(toList());

Eu fiz uma versão genérica:

private <T, R> Collector<T, ?, Stream<T>> distinctByKey(Function<T, R> keyExtractor) {
    return Collectors.collectingAndThen(
            toMap(
                    keyExtractor,
                    t -> t,
                    (t1, t2) -> t1
            ),
            (Map<R, T> map) -> map.values().stream()
    );
}

Um exemplo:

Stream.of(new Person("Jean"), 
          new Person("Jean"),
          new Person("Paul")
)
    .filter(...)
    .collect(distinctByKey(Person::getName)) // return a stream of Person with 2 elements, jean and Paul
    .map(...)
    .collect(toList())

Outra biblioteca que suporta isso é o jOOλ , e seu Seq.distinct(Function<T,U>)método:

Seq.seq(persons).distinct(Person::getName).toList();

Sob o capô , ele faz praticamente a mesma coisa que a resposta aceita .

Set<YourPropertyType> set = new HashSet<>();
list
        .stream()
        .filter(it -> set.add(it.getYourProperty()))
        .forEach(it -> ...);

Minha abordagem é agrupar todos os objetos com a mesma propriedade, reduzir os grupos para o tamanho de 1 e, finalmente, coletá-los como a List.

  List<YourPersonClass> listWithDistinctPersons =   persons.stream()
            //operators to remove duplicates based on person name
            .collect(Collectors.groupingBy(p -> p.getName()))
            .values()
            .stream()
            //cut short the groups to size of 1
            .flatMap(group -> group.stream().limit(1))
            //collect distinct users as list
            .collect(Collectors.toList());

A lista de objetos distintos pode ser encontrada usando:

 List distinctPersons = persons.stream()
                    .collect(Collectors.collectingAndThen(
                            Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person:: getName))),
                            ArrayList::new));

A maneira mais fácil de implementar isso é pular o recurso de classificação, pois ele já fornece um opcional Comparatorque pode ser criado usando a propriedade de um elemento. Então você precisa filtrar as duplicatas, o que pode ser feito usando um statefull Predicateque usa o fato de que, para um fluxo classificado, todos os elementos iguais são adjacentes:

Comparator<Person> c=Comparator.comparing(Person::getName);
stream.sorted(c).filter(new Predicate<Person>() {
    Person previous;
    public boolean test(Person p) {
      if(previous!=null && c.compare(previous, p)==0)
        return false;
      previous=p;
      return true;
    }
})./* more stream operations here */;

Obviamente, um statefull Predicatenão é seguro para threads, no entanto, se essa for sua necessidade, você pode mover essa lógica para ae Collectordeixar o fluxo cuidar da segurança de threads ao usar o seu Collector. Isso depende do que você deseja fazer com o fluxo de elementos distintos que você não nos contou na sua pergunta.

Com base na resposta de @ josketres, criei um método de utilitário genérico:

Você pode tornar isso mais amigável ao Java 8 criando um coletor .

public static <T> Set<T> removeDuplicates(Collection<T> input, Comparator<T> comparer) {
    return input.stream()
            .collect(toCollection(() -> new TreeSet<>(comparer)));
}


@Test
public void removeDuplicatesWithDuplicates() {
    ArrayList<C> input = new ArrayList<>();
    Collections.addAll(input, new C(7), new C(42), new C(42));
    Collection<C> result = removeDuplicates(input, (c1, c2) -> Integer.compare(c1.value, c2.value));
    assertEquals(2, result.size());
    assertTrue(result.stream().anyMatch(c -> c.value == 7));
    assertTrue(result.stream().anyMatch(c -> c.value == 42));
}

@Test
public void removeDuplicatesWithoutDuplicates() {
    ArrayList<C> input = new ArrayList<>();
    Collections.addAll(input, new C(1), new C(2), new C(3));
    Collection<C> result = removeDuplicates(input, (t1, t2) -> Integer.compare(t1.value, t2.value));
    assertEquals(3, result.size());
    assertTrue(result.stream().anyMatch(c -> c.value == 1));
    assertTrue(result.stream().anyMatch(c -> c.value == 2));
    assertTrue(result.stream().anyMatch(c -> c.value == 3));
}

private class C {
    public final int value;

    private C(int value) {
        this.value = value;
    }
}

Talvez seja útil para alguém. Eu tinha um pouco mais um requisito. Ter uma lista de objetos Ade terceiros remove todos os que têm o mesmo A.bcampo para o mesmo A.id(vários Aobjetos com o mesmo A.idna lista). A resposta da partição de fluxo por Tagir Valeev me inspirou a usar os Collectorretornos personalizados Map<A.id, List<A>>. Simples flatMapfará o resto.

 public static <T, K, K2> Collector<T, ?, Map<K, List<T>>> groupingDistinctBy(Function<T, K> keyFunction, Function<T, K2> distinctFunction) {
    return groupingBy(keyFunction, Collector.of((Supplier<Map<K2, T>>) HashMap::new,
            (map, error) -> map.putIfAbsent(distinctFunction.apply(error), error),
            (left, right) -> {
                left.putAll(right);
                return left;
            }, map -> new ArrayList<>(map.values()),
            Collector.Characteristics.UNORDERED)); }

Eu tive uma situação, na qual eu deveria obter elementos distintos da lista com base em 2 chaves. Se você deseja distintas com base em duas chaves ou pode compor uma chave, tente este

class Person{
    int rollno;
    String name;
}
List<Person> personList;


Function<Person, List<Object>> compositeKey = personList->
        Arrays.<Object>asList(personList.getName(), personList.getRollno());

Map<Object, List<Person>> map = personList.stream().collect(Collectors.groupingBy(compositeKey, Collectors.toList()));

List<Object> duplicateEntrys = map.entrySet().stream()`enter code here`
        .filter(settingMap ->
                settingMap.getValue().size() > 1)
        .collect(Collectors.toList());

No meu caso, eu precisava controlar qual era o elemento anterior. Em seguida, criei um Predicado com estado, onde eu controlava se o elemento anterior era diferente do elemento atual; nesse caso, eu o mantinha.

public List<Log> fetchLogById(Long id) {
    return this.findLogById(id).stream()
        .filter(new LogPredicate())
        .collect(Collectors.toList());
}

public class LogPredicate implements Predicate<Log> {

    private Log previous;

    public boolean test(Log atual) {
        boolean isDifferent = previouws == null || verifyIfDifferentLog(current, previous);

        if (isDifferent) {
            previous = current;
        }
        return isDifferent;
    }

    private boolean verifyIfDifferentLog(Log current, Log previous) {
        return !current.getId().equals(previous.getId());
    }

}

Minha solução nesta listagem:

List<HolderEntry> result ....

List<HolderEntry> dto3s = new ArrayList<>(result.stream().collect(toMap(
            HolderEntry::getId,
            holder -> holder,  //or Function.identity() if you want
            (holder1, holder2) -> holder1 
    )).values());

Na minha situação, quero encontrar valores distintos e colocá-los na lista.

Enquanto a resposta mais alta votada é absolutamente a melhor resposta em Java 8, é ao mesmo tempo absolutamente pior em termos de desempenho. Se você realmente deseja um aplicativo de baixo desempenho e ruim, vá em frente e use-o. O simples requisito de extrair um conjunto exclusivo de Nomes de Pessoas deve ser alcançado com mero "For-Each" e um "Set". As coisas pioram ainda mais se a lista estiver acima do tamanho 10.

Considere que você tem uma coleção de 20 objetos, assim:

public static final List<SimpleEvent> testList = Arrays.asList(
            new SimpleEvent("Tom"), new SimpleEvent("Dick"),new SimpleEvent("Harry"),new SimpleEvent("Tom"),
            new SimpleEvent("Dick"),new SimpleEvent("Huckle"),new SimpleEvent("Berry"),new SimpleEvent("Tom"),
            new SimpleEvent("Dick"),new SimpleEvent("Moses"),new SimpleEvent("Chiku"),new SimpleEvent("Cherry"),
            new SimpleEvent("Roses"),new SimpleEvent("Moses"),new SimpleEvent("Chiku"),new SimpleEvent("gotya"),
            new SimpleEvent("Gotye"),new SimpleEvent("Nibble"),new SimpleEvent("Berry"),new SimpleEvent("Jibble"));

Onde seu objeto se SimpleEventparece com isso:

public class SimpleEvent {

private String name;
private String type;

public SimpleEvent(String name) {
    this.name = name;
    this.type = "type_"+name;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getType() {
    return type;
}

public void setType(String type) {
    this.type = type;
}
}

E para testar, você tem um código JMH como este (observe que estou usando o mesmo Predicado distintoByKey mencionado na resposta aceita):

@Benchmark
@OutputTimeUnit(TimeUnit.SECONDS)
public void aStreamBasedUniqueSet(Blackhole blackhole) throws Exception{

    Set<String> uniqueNames = testList
            .stream()
            .filter(distinctByKey(SimpleEvent::getName))
            .map(SimpleEvent::getName)
            .collect(Collectors.toSet());
    blackhole.consume(uniqueNames);
}

@Benchmark
@OutputTimeUnit(TimeUnit.SECONDS)
public void aForEachBasedUniqueSet(Blackhole blackhole) throws Exception{
    Set<String> uniqueNames = new HashSet<>();

    for (SimpleEvent event : testList) {
        uniqueNames.add(event.getName());
    }
    blackhole.consume(uniqueNames);
}

public static void main(String[] args) throws RunnerException {
    Options opt = new OptionsBuilder()
            .include(MyBenchmark.class.getSimpleName())
            .forks(1)
            .mode(Mode.Throughput)
            .warmupBatchSize(3)
            .warmupIterations(3)
            .measurementIterations(3)
            .build();

    new Runner(opt).run();
}

Então você terá resultados de benchmark como este:

Benchmark                                  Mode  Samples        Score  Score error  Units
c.s.MyBenchmark.aForEachBasedUniqueSet    thrpt        3  2635199.952  1663320.718  ops/s
c.s.MyBenchmark.aStreamBasedUniqueSet     thrpt        3   729134.695   895825.697  ops/s

E, como você pode ver, um For-Each simples é 3 vezes melhor em taxa de transferência e menos em pontuação de erro em comparação com o Java 8 Stream.

Maior rendimento, melhor desempenho

Here is the example
public class PayRoll {

    private int payRollId;
    private int id;
    private String name;
    private String dept;
    private int salary;


    public PayRoll(int payRollId, int id, String name, String dept, int salary) {
        super();
        this.payRollId = payRollId;
        this.id = id;
        this.name = name;
        this.dept = dept;
        this.salary = salary;
    }
} 

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class Prac {
    public static void main(String[] args) {

        int salary=70000;
        PayRoll payRoll=new PayRoll(1311, 1, "A", "HR", salary);
        PayRoll payRoll2=new PayRoll(1411, 2    , "B", "Technical", salary);
        PayRoll payRoll3=new PayRoll(1511, 1, "C", "HR", salary);
        PayRoll payRoll4=new PayRoll(1611, 1, "D", "Technical", salary);
        PayRoll payRoll5=new PayRoll(711, 3,"E", "Technical", salary);
        PayRoll payRoll6=new PayRoll(1811, 3, "F", "Technical", salary);
        List<PayRoll>list=new ArrayList<PayRoll>();
        list.add(payRoll);
        list.add(payRoll2);
        list.add(payRoll3);
        list.add(payRoll4);
        list.add(payRoll5);
        list.add(payRoll6);


        Map<Object, Optional<PayRoll>> k = list.stream().collect(Collectors.groupingBy(p->p.getId()+"|"+p.getDept(),Collectors.maxBy(Comparator.comparingInt(PayRoll::getPayRollId))));


        k.entrySet().forEach(p->
        {
            if(p.getValue().isPresent())
            {
                System.out.println(p.getValue().get());
            }
        });



    }
}

Output:

PayRoll [payRollId=1611, id=1, name=D, dept=Technical, salary=70000]
PayRoll [payRollId=1811, id=3, name=F, dept=Technical, salary=70000]
PayRoll [payRollId=1411, id=2, name=B, dept=Technical, salary=70000]
PayRoll [payRollId=1511, id=1, name=C, dept=HR, salary=70000]

Se você deseja seguir a lista de pessoas, seria a maneira mais simples

Set<String> set = new HashSet<>(persons.size());
persons.stream().filter(p -> set.add(p.getName())).collect(Collectors.toList());

Além disso, se você deseja encontrar uma lista distinta ou exclusiva de nomes , não Pessoa , você também pode usar os dois métodos a seguir.

Método 1: usando distinct

persons.stream().map(x->x.getName()).distinct.collect(Collectors.toList());

Método 2: usando HashSet

Set<E> set = new HashSet<>();
set.addAll(person.stream().map(x->x.getName()).collect(Collectors.toList()));

O código mais simples que você pode escrever:

    persons.stream().map(x-> x.getName()).distinct().collect(Collectors.toList());