在C#中从List<T>中移除重复项

Question

有没有快速去重C#中通用List的方法？

- JC Grubbs

---

你是否关心结果中元素的顺序？这可能会排除一些解决方案。 - Colonel Panic

一行代码解决方案：ICollection<MyClass> withoutDuplicates = new HashSet<MyClass>(inputList); 该代码使用哈希集合（HashSet）来去除输入列表（inputList）中的重复项，并将结果保存在一个不包含重复项的MyClass对象集合（withoutDuplicates）中。 - Harald Coppoolse

这个方法会在哪里被使用？ - kimiahdri

Answer 1

如果您正在使用 .Net 3+，则可以使用 Linq。

List<T> withDupes = LoadSomeData();
List<T> noDupes = withDupes.Distinct().ToList();

- Factor Mystic

---

不，它可以使用包含任何类型对象的列表。但是您需要覆盖该类型的默认比较器。像这样：public override bool Equals(object obj){...} - BaBu

在你的类中重写ToString()和GetHashCode()总是一个好主意，这样这种事情就能够正常工作。 - B Seven

你也可以使用MoreLinQ Nuget包，它具有.DistinctBy()扩展方法。非常有用。 - yu_ominae

Distinct不能保证保留顺序，具体实现有关。 - Tod Cunningham

这不是一个完整的解决方案，对于复杂对象无法起作用。如果需要适用于任何类型对象的解决方案，请参见我的答案 https://dev59.com/CnVD5IYBdhLWcg3wOo9h#70162977 - Onat Korucu

Answer 2

也许你应该考虑使用HashSet。

根据MSDN链接:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> evenNumbers = new HashSet<int>();
        HashSet<int> oddNumbers = new HashSet<int>();

        for (int i = 0; i < 5; i++)
        {
            // Populate numbers with just even numbers.
            evenNumbers.Add(i * 2);

            // Populate oddNumbers with just odd numbers.
            oddNumbers.Add((i * 2) + 1);
        }

        Console.Write("evenNumbers contains {0} elements: ", evenNumbers.Count);
        DisplaySet(evenNumbers);

        Console.Write("oddNumbers contains {0} elements: ", oddNumbers.Count);
        DisplaySet(oddNumbers);

        // Create a new HashSet populated with even numbers.
        HashSet<int> numbers = new HashSet<int>(evenNumbers);
        Console.WriteLine("numbers UnionWith oddNumbers...");
        numbers.UnionWith(oddNumbers);

        Console.Write("numbers contains {0} elements: ", numbers.Count);
        DisplaySet(numbers);
    }

    private static void DisplaySet(HashSet<int> set)
    {
        Console.Write("{");
        foreach (int i in set)
        {
            Console.Write(" {0}", i);
        }
        Console.WriteLine(" }");
    }
}

/* This example produces output similar to the following:
 * evenNumbers contains 5 elements: { 0 2 4 6 8 }
 * oddNumbers contains 5 elements: { 1 3 5 7 9 }
 * numbers UnionWith oddNumbers...
 * numbers contains 10 elements: { 0 2 4 6 8 1 3 5 7 9 }
 */

- Jason Baker

---

信不信由你，用 List 处理 100,000 个字符串需要 400 秒和 8MB 的内存，而我自己的解决方案只需要 2.5 秒和 28MB 的内存，使用 HashSet 只需要 0.1 秒和 11MB 的内存！ - sasjaq

HashSet 没有索引，因此不能始终使用它。我必须创建一个没有重复项的大型列表，然后在虚拟模式下将其用于 ListView。首先创建 HashSet<> 然后转换为 List<>（这样 ListView 可以通过索引访问项目）是超级快的。List<>.Contains() 的速度太慢了。 - Sinatr

如果在这个特定的上下文中提供一个使用哈希集的示例会很有帮助。 - Nathan McKaskle

这怎么能算作答案呢？这只是一个链接。 - mcont

HashSet 在大多数情况下都非常好用。但是如果你有一个像 DateTime 这样的对象，它通过引用进行比较而不是值，所以你最终仍然会得到重复的结果。 - Jason McKindly

Answer 3

怎么样：

var noDupes = list.Distinct().ToList();

在 .net 3.5 中？

- kronoz

---

它是否复制了列表？ - Darkgaze

@darkgaze 这只是创建了另一个仅包含唯一条目的列表。因此，任何重复项都将被删除，您将得到一个每个位置都有不同对象的列表。 - hexagod

这适用于列表中包含重复项且需要获取唯一列表的列表吗？ - venkat

Answer 4

只需使用与列表相同类型的HashSet初始化:

var noDupes = new HashSet<T>(withDupes);

或者，如果您想返回一个列表：

var noDupsList = new HashSet<T>(withDupes).ToList();

- Even Mien

---

如果您需要一个 List<T> 作为结果，请使用 new HashSet<T>(withDupes).ToList()。 - Tim Schmelter

Answer 5

将其排序，然后检查相邻的两个元素是否重复，因为重复的元素会聚集在一起。

类似于这样：

list.Sort();
Int32 index = list.Count - 1;
while (index > 0)
{
    if (list[index] == list[index - 1])
    {
        if (index < list.Count - 1)
            (list[index], list[list.Count - 1]) = (list[list.Count - 1], list[index]);
        list.RemoveAt(list.Count - 1);
        index--;
    }
    else
        index--;
}

注：

• 比较是从后往前进行的，以避免每次移除后都要重新排序
• 此示例现在使用C#值元组进行交换，请替换为适当的代码（如果不能使用）
• 最终结果不再排序

- lassevk

---

如果我没记错的话，上面提到的大多数方法都只是这些例程的抽象，对吧？我本来会采用你的方法，Lasse，因为这就是我在脑海中想象数据移动的方式。但现在我对一些建议之间的性能差异感兴趣。 - Ian Patrick Hughes

实现并测量它们，这是确保的唯一方法。即使是大O符号在实际性能指标上也无法帮助您，只有增长效应关系才行。 - Lasse V. Karlsen

我喜欢这种方法，它更易于移植到其他语言。 - OKEEngine

不要这样做，它非常缓慢。在List中使用RemoveAt是一个代价很高的操作。 - Clément

Clément是正确的。拯救这个问题的方法是将其包装在一个使用枚举器生成并仅返回不同值的方法中。或者，您可以将值复制到新数组或列表中。 - JHubbard80

Answer 6

我喜欢使用这个命令：

List<Store> myStoreList = Service.GetStoreListbyProvince(provinceId)
                                                 .GroupBy(s => s.City)
                                                 .Select(grp => grp.FirstOrDefault())
                                                 .OrderBy(s => s.City)
                                                 .ToList();

我在列表中有这些字段：Id、StoreName、City、PostalCode。我想在下拉菜单中显示具有重复值的城市列表。 解决方案：按城市分组，然后选择第一个放入列表。

- Eric

---

这个方法适用于我有多个具有相同键的项目，并且必须仅保留具有最新更新日期的项目的情况。因此，使用“distinct”方法不起作用。 - Paul Evans

Answer 7

对我有效。只需使用

List<Type> liIDs = liIDs.Distinct().ToList<Type>();

用您想要的类型（例如int）替换“Type”。

- Hossein Sarshar

---

Distinct在Linq中，而不是MSDN页面所报告的System.Collections.Generic。 - Almo

这个答案（2012年）似乎与此页面上另外两个来自2008年的答案相同？ - Jon Schneider

Answer 8

如kronoz在 .Net 3.5 中所说，您可以使用 Distinct()。

在 .Net 2 中，您可以模拟它：

public IEnumerable<T> DedupCollection<T> (IEnumerable<T> input) 
{
    var passedValues = new HashSet<T>();

    // Relatively simple dupe check alg used as example
    foreach(T item in input)
        if(passedValues.Add(item)) // True if item is new
            yield return item;
}

这可以用于去重任何集合，并按照原始顺序返回值。

通常情况下，过滤集合（像Distinct()和这个示例一样）比从中删除项要快得多。

- Keith

---

@DrJokepu - 实际上我没有意识到HashSet构造函数进行了去重，这使得它在大多数情况下更好。然而，这将保留排序顺序，而HashSet则不会。 - Keith

HashSet<T>是在3.5中引入的。 - thorn0

@thorn 真的吗？跟踪起来很难。在这种情况下，您可以使用 Dictionary<T, object> 替换 .Contains 为 .ContainsKey，.Add(item) 替换为 .Add(item, null)。 - Keith

@Keith，根据我的测试，HashSet 保留顺序，而 Distinct() 则不保留。 - Dennis T --Reinstate Monica--

@DennisT HashSet 有时会根据使用的键类型和输入的相对顺序而发生变化。DedupCollection 代码片段将按照它们输入的顺序返回结果。 - Keith

Answer 9

扩展方法可能是一个不错的选择... 就像这样：

public static List<T> Deduplicate<T>(this List<T> listToDeduplicate)
{
    return listToDeduplicate.Distinct().ToList();
}

然后可以像这样调用，例如：

List<int> myFilteredList = unfilteredList.Deduplicate();

- Geoff Taylor

Answer 10

在Java中（我假设C#是大致相同的）：

list = new ArrayList<T>(new HashSet<T>(list))

如果您确实希望改变原始列表：

List<T> noDupes = new ArrayList<T>(new HashSet<T>(list));
list.clear();
list.addAll(noDupes);

为了保持顺序，只需将 HashSet 替换为 LinkedHashSet。

- Tom Hawtin - tackline

---

在C＃中，它将是：List<T> noDupes = new List<T>(new HashSet<T>(list)); list.Clear(); list.AddRange(noDupes); - smohamed

在C#中，这样做更容易：var noDupes = new HashSet<T>(list); list.Clear(); list.AddRange(noDupes); :) - nawfal