c# - net - remarks/>

La forma más rápida de eliminar el valor duplicado de una lista<> por lambda

Question

¿Cuál es la forma más rápida de eliminar los valores duplicados de una lista? Asumir List<long> longs = new List<long> { 1, 2, 3, 4, 3, 2, 5 }; Entonces, soy interesante en el uso de lambda para eliminar el duplicado y devolví: {1, 2, 3, 4, 5} . ¿Cuál es tu sugerencia?

Answer 1

En su lugar:

    public static void DistinctValues<T>(List<T> list)
    {
        list.Sort();

        int src = 0;
        int dst = 0;
        while (src < list.Count)
        {
            var val = list[src];
            list[dst] = val;

            ++dst;
            while (++src < list.Count && list[src].Equals(val)) ;
        }
        if (dst < list.Count)
        {
            list.RemoveRange(dst, list.Count - dst);
        }
    }

Answer 2

Hay un método Distinct (). debería funcionar.

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

Answer 3

La forma más fácil de obtener una nueva lista sería:

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

¿Eso es lo suficientemente bueno para ti, o necesitas mutar la lista existente ? Este último es significativamente más prolijo.

Tenga en cuenta que Distinct() no garantiza conservar el orden original, pero en la implementación actual lo hará, y esa es la implementación más natural . Vea mi blog de Edulinq sobre Distinct() para más información.

Si no necesita que sea una List<long> , puede mantenerlo como sigue:

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

En este punto, pasará por la eliminación de duplicados cada vez que itere sobre un unique . Si eso es bueno o no, dependerá de sus requisitos.

Answer 4

Puede usar este método de extensión para enumerables que contienen tipos más complejos:

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

Answer 5

Si desea seguir con la Lista original en lugar de crear una nueva, puede hacer algo similar a lo que hace el método de extensión Distinct() internamente, es decir, usar un HashSet para verificar la exclusividad:

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

La clase List proporciona este conveniente método RemoveAll(predicate) que descarta todos los elementos que no satisfacen la condición especificada por el predicado. El predicado es un delegado que toma un parámetro del tipo de elemento de la lista y devuelve un valor de bool. El método Add() HashSet devuelve verdadero solo si el conjunto aún no contiene el elemento. Por lo tanto, al eliminar cualquier elemento de la lista que no se pueda agregar al conjunto, se eliminan de manera efectiva todos los duplicados.

Answer 6

Una implementación intuitiva simple `public static List RemoveDuplicates (List listPoints) {List result = new List ();

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

        return result;
    }`

Answer 7

List<long> distinctlongs = longs.Distinct().OrderBy(x => x).ToList();