web-dev-qa-db-fra.com

Le moyen le plus rapide de supprimer une valeur en double d'une liste <> par lambda

quel est le moyen le plus rapide de supprimer les valeurs en double d'une liste. Présumer List<long> longs = new List<long> { 1, 2, 3, 4, 3, 2, 5 }; Je suis donc intéressant d’utiliser lambda pour supprimer les doublons et retourner: {1, 2, 3, 4, 5}. Quelle est votre suggestion?

c#listc#-4.0lambdageneric-list
68
Saeid

Le moyen le plus simple d’obtenir une nouvelle liste serait:

List<long> unique = longs.Distinct().ToList();

Cela vous convient-il ou devez-vous modifier la liste existante ? Ce dernier est beaucoup plus long.

Notez que Distinct() n'est pas garanti pour conserver l'ordre d'origine, mais dans l'implémentation actuelle, va - et c'est la plus mise en œuvre naturelle . Voir mon billet de blog Edulinq sur Distinct() pour plus d'informations.

Si vous n'en avez pas besoin pour être un List<long>, Vous pouvez simplement le conserver comme suit:

IEnumerable<long> unique = longs.Distinct();

À ce stade, il passera par la duplication à chaque fois que vous parcourez unique bien que. Que cela soit bon ou non dépendra de vos exigences.

123
Jon Skeet

Vous pouvez utiliser cette méthode d'extension pour les énumérations contenant des types plus complexes:

IEnumerable<Foo> distinctList = sourceList.DistinctBy(x => x.FooName);

public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
    this IEnumerable<TSource> source,
    Func<TSource, TKey> keySelector)
{
    var knownKeys = new HashSet<TKey>();
    return source.Where(element => knownKeys.Add(keySelector(element)));
}
78
Jon Rea

Il existe une méthode Distinct (). ça devrait marcher.

List<long> longs = new List<long> { 1, 2, 3, 4, 3, 2, 5 };
var distinctList = longs.Distinct().ToList();
7
Pongsathon.keng

Si vous souhaitez conserver la liste d'origine au lieu d'en créer une nouvelle, vous pouvez utiliser quelque chose de similaire à ce que la méthode d'extension Distinct() utilise en interne, c'est-à-dire utiliser un HashSet pour vérifier l'unicité:

HashSet<long> set = new HashSet<long>(longs.Count);
longs.RemoveAll(x => !set.Add(x));

La classe List fournit cette méthode pratique RemoveAll(predicate) qui supprime tous les éléments ne satisfaisant pas la condition spécifiée par le prédicat. Le prédicat est un délégué prenant un paramètre du type d'élément de la liste et renvoyant une valeur bool. La méthode Add() du HashSet ne renvoie true que si l'ensemble ne contient pas encore l'élément. Ainsi, en supprimant tous les éléments de la liste qui ne peuvent pas être ajoutés à l'ensemble, vous supprimez effectivement tous les doublons.

6
Wormbo
List<long> distinctlongs = longs.Distinct().OrderBy(x => x).ToList();
2
Nikhil Agrawal

Une implémentation intuitive simple

public static List<PointF> RemoveDuplicates(List<PointF> listPoints)
{
    List<PointF> result = new List<PointF>();

    for (int i = 0; i < listPoints.Count; i++)
    {
        if (!result.Contains(listPoints[i]))
            result.Add(listPoints[i]);
    }

    return result;
}
1
Moctar Haiz