Java 8 Distinct par propriété

Dans Java 8, comment puis-je filtrer une collection à l'aide de l' StreamAPI en vérifiant la distinction d'une propriété de chaque objet?

Par exemple, j'ai une liste de Person objets et je veux supprimer des personnes du même nom,

persons.stream().distinct();

Va utiliser la vérification d'égalité par défaut pour un Person objet, j'ai donc besoin de quelque chose comme,

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

Malheureusement, la distinct()méthode n'a pas une telle surcharge. Sans modifier le contrôle d'égalité à l'intérieur de la Personclasse, est-il possible de le faire succinctement?

Considérez distinctcomme un filtre dynamique . Voici une fonction qui retourne un prédicat qui maintient l'état de ce qu'il a vu précédemment, et qui retourne si l'élément donné a été vu pour la première fois:

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

Ensuite, vous pouvez écrire:

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

Notez que si le flux est ordonné et est exécuté en parallèle, cela préservera un élément arbitraire parmi les doublons, au lieu du premier, comme le distinct()fait.

(C'est essentiellement la même que ma réponse à cette question: Java Lambda Stream Distinct () sur une clé arbitraire? )

Une alternative serait de placer les personnes sur une carte en utilisant le nom comme clé:

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

Notez que la Personne conservée, en cas de nom en double, sera la première rencontrée.

Vous pouvez encapsuler les objets personne dans une autre classe, qui compare uniquement les noms des personnes. Ensuite, vous déballez les objets enveloppés pour obtenir à nouveau un flux de personne. Les opérations de flux peuvent se présenter comme suit:

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

La classe Wrapperpourrait ressembler à ceci:

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

Une autre solution, en utilisant Set. Ce n'est peut-être pas la solution idéale, mais ça marche

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

Ou si vous pouvez modifier la liste d'origine, vous pouvez utiliser la méthode removeIf

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

Il existe une approche plus simple en utilisant un TreeSet avec un comparateur personnalisé.

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

Nous pouvons également utiliser RxJava ( bibliothèque d' extensions réactives très puissante )

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

ou

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

Vous pouvez utiliser le groupingBycollecteur:

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

Si vous souhaitez avoir un autre flux, vous pouvez utiliser ceci:

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

Vous pouvez utiliser la distinct(HashingStrategy)méthode dans les collections Eclipse .

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

Si vous pouvez refactoriser personspour implémenter une interface Eclipse Collections, vous pouvez appeler la méthode directement dans la liste.

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

HashingStrategy est simplement une interface de stratégie qui vous permet de définir des implémentations personnalisées d'equals et de hashcode.

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

Remarque: je suis un committer pour les collections Eclipse.

Je vous recommande d'utiliser Vavr , si vous le pouvez. Avec cette bibliothèque, vous pouvez effectuer les opérations suivantes:

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

Vous pouvez utiliser la bibliothèque StreamEx :

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

En étendant la réponse de Stuart Marks, cela peut être fait de manière plus courte et sans carte simultanée (si vous n'avez pas besoin de flux parallèles):

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

Appelez ensuite:

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

Approche similaire utilisée par Saeed Zarinfam mais plus de style Java 8 :)

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

J'ai fait une version générique:

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

Un exemple:

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

Une autre bibliothèque qui prend en charge ceci est jOOλ , et sa Seq.distinct(Function<T,U>)méthode:

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

Sous le capot , cela fait pratiquement la même chose que la réponse acceptée .

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

Mon approche consiste à regrouper tous les objets ayant la même propriété, puis à raccourcir les groupes à la taille 1, puis à les collecter finalement sous la forme d'un 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());

La liste des objets distincts peut être trouvée en utilisant:

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

La façon la plus simple de l'implémenter est de sauter sur la fonction de tri car elle fournit déjà une option Comparatorqui peut être créée en utilisant la propriété d'un élément. Ensuite, vous devez filtrer les doublons, ce qui peut être fait en utilisant un état Predicatequi utilise le fait que pour un flux trié, tous les éléments égaux sont adjacents:

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

Bien sûr, un état Predicaten'est pas sûr pour les threads, mais si tel est votre besoin, vous pouvez déplacer cette logique dans un Collectoret laisser le flux s'occuper de la sécurité des threads lorsque vous utilisez votre Collector. Cela dépend de ce que vous voulez faire avec le flux d'éléments distincts que vous ne nous avez pas dit dans votre question.

Sur la base de la réponse de @ josketres, j'ai créé une méthode utilitaire générique:

Vous pouvez rendre cela plus compatible avec Java 8 en créant un collecteur .

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

Peut-être sera utile à quelqu'un. J'avais un peu une autre exigence. Avoir la liste des objets Ade tiers supprimer tous ceux qui ont le même A.bchamp pour le même A.id(plusieurs Aobjets avec le même A.iddans la liste). Partition flux réponse par Tagir Valeev m'a inspiré d'utiliser la coutume Collectorqui les retours Map<A.id, List<A>>. Simple flatMapfera le reste.

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

J'ai eu une situation, où j'étais supposé obtenir des éléments distincts de la liste sur la base de 2 clés. Si vous voulez une distinction sur la base de deux clés ou une clé composite, essayez ceci

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

Dans mon cas, j'avais besoin de contrôler quel était l'élément précédent. J'ai ensuite créé un prédicat avec état où j'ai contrôlé si l'élément précédent était différent de l'élément actuel, dans ce cas, je l'ai conservé.

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

}

Ma solution dans cette liste:

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

Dans ma situation, je veux trouver des valeurs distinctes et les mettre dans la liste.

Alors que la réponse la plus élevée est la meilleure réponse à Java 8, elle est en même temps absolument pire en termes de performances. Si vous voulez vraiment une mauvaise application peu performante, allez-y et utilisez-la. La simple exigence d'extraction d'un ensemble unique de noms de personne doit être obtenue par de simples «pour chacun» et un «ensemble». Les choses empirent encore si la liste dépasse 10.

Considérez que vous avez une collection de 20 objets, comme ceci:

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

Où vous vous opposez SimpleEventressemble à ceci:

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

Et pour tester, vous avez un code JMH comme celui-ci, (veuillez noter que j'utilise le même prédicat distinctByKey mentionné dans la réponse acceptée):

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

Ensuite, vous aurez des résultats de référence comme celui-ci:

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

Et comme vous pouvez le voir, un simple For-Each a un débit 3 fois supérieur et un score d'erreur inférieur à Java 8 Stream.

Plus le débit est élevé, meilleures sont les performances

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]

Si vous voulez lister les personnes suivantes, ce serait le moyen le plus simple

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

En outre, si vous souhaitez rechercher une liste de noms distincte ou unique , et non Personne , vous pouvez également utiliser la méthode suivante.

Méthode 1: utilisation distinct

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

Méthode 2: utilisation HashSet

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

Le code le plus simple que vous puissiez écrire:

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