web-dev-qa-db-fra.com

Supprimer les doublons de la liste à l'aide de la goyave

Comment pouvons-nous supprimer les doublons de la liste à l'aide de Guava api?

Actuellement, je suis ceci:

private List<T> removeDuplicate(List<T> list){
return new ArrayList<T>(new LinkedHashSet<T>(list));
}
javalistgenericsarraylistguava
34
Priyank Doshi

Le moyen le plus efficace est probablement ImmutableSet.copyOf(list).asList(), qui élimine les doublons et préserve l'ordre d'itération.

(Mais votre implémentation avec LinkedHashSet serait presque aussi efficace, et ne renoncerait pas à des valeurs nulles, dans le cas peu probable où vous vouliez réellement des valeurs nulles dans votre collection.)

69
Louis Wasserman

J'adore réponse de Louis pour sa simplicité (et parce que c'est la seule réponse qui ne nécessite pas 2 itérations complètes), mais malheureusement dans le monde réel, vous rencontrez souvent des situations où null se produit. Voici une version null-safe légèrement plus longue:

ImmutableSet.copyOf(
    Iterables.filter(
        list, Predicates.not(Predicates.isNull()))).asList();

Ou, avec des importations statiques:

copyOf(filter(list, not(isNull()))).asList();

Bien sûr, vous devez être conscient du fait que toutes les valeurs null seront perdues de la liste.

12
Sean Patrick Floyd

avec prédicat générique

class DuplicateRemover<T> implements Predicate<T> {

    private final Set<T> set = new HashSet<>();

    @Override
    public boolean apply(T input) {

        boolean flag = set.contains(input);

        if (!flag) {
            set.add(input);
        }

        return !flag;
    }

}
7
jeton

Si vous voulez utiliser la goyave à tout prix, vous pouvez le faire

return new ArrayList<T>(HashMultiSet<T>.create(list).elementSet())
1
halex

Je ne recommande vraiment pas d'utiliser (Linked)HashMultiSet Pour effectuer des tâches qui sont généralement effectuées avec ArrayList et (Linked)HashSet Comme OP mentionné ci-dessus - il est moins lisible pour les Java programmeur et (probablement) moins efficace.

Au lieu de cela, utilisez au moins des constructeurs d'usine statiques comme newArrayList et newLinkedHashSet pour éviter tous ces <T> S:

private static <T> List<T> removeDuplicate(final List<T> list) {
  return Lists.newArrayList(Sets.newLinkedHashSet(list));
}

Cependant, vous pouvez le faire de manière plus "goyave" - ​​en en évitant les valeurs nulles et en utilisant collections immuables .

Donc, si votre collection ne peut pas avoir des éléments nuls, je suggère d'utiliser ensemble immuable au lieu de mutable et moins efficace :

private static <T> List<T> removeDuplicate(final List<T> list) {
  return Lists.newArrayList(ImmutableSet.copyOf(list));
}

Il copie toujours des objets deux fois, alors envisagez d'être totalement immuable et de changer la signature de la méthode pour renvoyer ImmutableList:

private static <T> ImmutableList<T> removeDuplicate(final List<T> list) {
  return ImmutableSet.copyOf(list).asList();
}

De cette façon, il n'y a qu'une seule copie impliquée, car ImmutableCollection.asList() renvoie une vue.

1
Xaerxess

Vous pouvez essayer l'API MultiSet de Guava pour supprimer les doublons.Ajoutez simplement votre liste à l'ensemble et utilisez la méthode de comptage.

MultiSet

0
UVM