Créer une liste distincte à partir de la liste existante dans Java 7 et 8?

Si j'ai:

List<Integer> listInts = { 1, 1, 3, 77, 2, 19, 77, 123, 14, 123... }

en Java, ce qui est un moyen efficace de créer un List<Integer> listDistinctInts contenant uniquement les distinctes valeurs de listInts?

Ma pensée est de créer un Set<Integer> setInts contenant toutes les valeurs du listInts alors appel List<Integer> listDistinctInts = new ArrayList<>(setInts);

Mais cela semble potentiellement inefficace - est-il une meilleure solution à l'aide de Java 7?

Je ne suis pas à l'aide de Java 8, mais je crois que l'aide, je pouvais faire quelque chose comme ceci(?):

List<Integer> listDistinctInts = listInts.stream().distinct().collect(Collectors.toList());

Cela serait-il plus performant que l'approche ci-dessus et/ou est-il un moyen plus efficace de le faire en Java 8?

Enfin, (et je suis conscient que le fait de poser de multiples questions peut-être mal vu mais c'est directement liée) si je ne se souciait de l' compter d'éléments distincts dans listInts est-il un moyen plus efficace pour obtenir cette valeur (en Java 7 et 8) - sans la création préalable d'une liste ou d'un ensemble de tous les éléments distincts?

Je suis le plus intéressé à Java en natif façons d'y parvenir et éviter la re-inventer de toutes les roues, mais roulé à la main le code ou les bibliothèques si elles offrent une meilleure clarté ou la performance. J'ai lu cette question relative à la Java - Liste Distincte des Objets mais ce n'est pas tout à fait clair sur les différences de performance entre les Java 7 et 8 approches ou s'il pourrait y avoir de meilleures techniques?

source d'informationauteur Matt Coubrough

3

Si vous utilisez Eclipse Collections (anciennement GS Collections), vous pouvez utiliser la méthode distinct().
```
ListIterable<Integer> listInts = FastList.newListWith(1, 1, 3, 77, 2, 19, 77, 123, 14, 123);
Assert.assertEquals(
        FastList.newListWith(1, 3, 77, 2, 19, 123, 14),
        listInts.distinct());
```
L'avantage de l'utilisation de distinct() au lieu de convertir à un Ensemble et ensuite revenir à une Liste, c'est que distinct() conserve l'ordre de la Liste d'origine, en conservant la première occurrence de chaque élément. Elle est implémentée en utilisant à la fois un Jeu et une Liste.
```
MutableSet<T> seenSoFar = UnifiedSet.newSet();
int size = list.size();
for (int i = 0; i < size; i++)
{
    T item = list.get(i);
    if (seenSoFar.add(item))
    {
        targetCollection.add(item);
    }
}
return targetCollection;
```
Si vous ne pouvez pas convertir votre Liste d'origine dans un GS Collections de type, vous pouvez utiliser ListAdapter pour obtenir la même API.
```
MutableList<Integer> distinct = ListAdapter.adapt(integers).distinct();
```
Il n'y a aucun moyen d'éviter la création de l'Ensemble. Encore, UnifiedSet est plus efficace que le HashSet donc il y aura un peu de vitesse en bénéficier.

Si tout ce que vous voulez, c'est le nombre d'articles distincts, il est plus efficace de créer un jeu sans la création de la liste.
```
Verify.assertSize(7, UnifiedSet.newSet(listInts));
```
Eclipse Collections 8.0 nécessite Java 8. Eclipse Collections De 7.x fonctionne bien avec Java 8, mais ne nécessite Java 5.

Remarque: je suis un committer pour Eclipse collections.
1

Vous devriez essayer new LinkedList(new HashSet(listInts)).
1

Goyave peut être votre choix:
```
ImmutableSet<Integer> set = ImmutableSet.copyOf(listInts);
```
L'API est très optimisé.

Il est plus RAPIDE que listInts.stream().distinct() et new LinkedHashSet<>(listInts).

Lors de l'ajout d'une valeur à une listInts vérifier:

int valueToAdd;
//...
if (!listInts.contains(valueToAdd)) {listInts.add(valueToAdd)}

si vous avez une liste existante, utiliser un pour chaque déclaration pour copier toutes les valeurs de cette liste, à nouveau, que vous voulez être "distinctes":

List<Integer> listWithRepeatedValues;
List<Integer> distinctList;
//...
for (Integer i : listWithRepeatedValues) {
    if (!listInts.contains(valueToAdd)) {distinctList.add(i);}
}

Ne vous inquiétez pas. À l'aide d'un HashSet est un joli moyen facile et efficace pour éliminer les doublons:

    Set<Integer> uniqueList = new HashSet<>();
    uniqueList.addAll(listInts);   //Add all elements eliminating duplicates

    for (int n : uniqueList)       //Check the results (in no particular order)
        System.out.println(n);

    System.out.println("Number distinct values: " + uniqueList.size());

En plus d'un scénario spécifique, juste au cas où le nombre de valeurs possibles est connu, n'est pas très grand, tandis que listInts est très grand.

Le moyen le plus efficace de compter le nombre d'entrées uniques dans la liste que je peux penser à est de:

    boolean[] counterTable = new boolean[124];
    int counter = 0;

    for (int n : listInts)
        if (!counterTable[n]) {
            counter++;
            counterTable[n] = true;
        }

    System.out.println("Number of distinct values: " + counter);

0

Cela devrait fonctionner:

yourlist.stream().carte(votre wrapper qui remplace d'égal à égal et hashchode méthode: nouvelle).distinct().carte(wrapper définis ci-dessus::méthode qui retourne le résultat final).recueillir des(Collectionneurs.toList());

Vous devez vous connecter pour publier un commentaire.