任何人都有一个快速的方法来重复C＃中的通用列表？
也许你应该考虑使用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 }
*/
在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);
要保留顺序，只需使用LinkedHashSet替换HashSet即可。
使用Linq的Union方法。
注意：除了存在之外，该解决方案不需要Linq的知识。
码
首先将以下内容添加到类文件的顶部：
using System.Linq;
现在，您可以使用以下命令从名为obj1的对象中删除重复项：
obj1 = obj1.Union(obj1).ToList();
注意：将obj1重命名为对象的名称。
这个怎么运作
ToList()返回一个新的List。这是必要的，因为像Union这样的Linq命令将结果作为IEnumerable结果返回，而不是修改原始List或返回新List。如果您不关心订单，您可以将物品推入HashSet，如果您想维持订单，您可以执行以下操作：
var unique = new List<T>();
var hs = new HashSet<T>();
foreach (T t in list)
if (hs.Add(t))
unique.Add(t);
或者Linq方式：
var hs = new HashSet<T>();
list.All( x => hs.Add(x) );
编辑：HashSet方法是O(N)时间和O(N)空间，而排序，然后使独特（由@lassevk和其他人建议）是O(N*lgN)时间和O(1)空间所以它不是那么清楚（因为它是乍一看）排序方式是低劣的（我为临时投票表示道歉......）
这是一种用于原位移除相邻重复项的扩展方法。首先调用Sort（）并传入相同的IComparer。这应该比Lasse V. Karlsen的版本更有效，它反复调用RemoveAt（导致多个块内存移动）。
public static void RemoveAdjacentDuplicates<T>(this List<T> List, IComparer<T> Comparer)
{
int NumUnique = 0;
for (int i = 0; i < List.Count; i++)
if ((i == 0) || (Comparer.Compare(List[NumUnique - 1], List[i]) != 0))
List[NumUnique++] = List[i];
List.RemoveRange(NumUnique, List.Count - NumUnique);
}
作为辅助方法（没有Linq）：
public static List<T> Distinct<T>(this List<T> list)
{
return (new HashSet<T>(list)).ToList();
}
这需要不同（没有重复元素的元素）并再次将其转换为列表：
List<type> myNoneDuplicateValue = listValueWithDuplicate.Distinct().ToList();
通过Nuget安装MoreLINQ软件包，您可以通过属性轻松区分对象列表
IEnumerable<Catalogue> distinctCatalogues = catalogues.DistinctBy(c => c.CatalogueCode);
可能更容易简单地确保重复项不会添加到列表中。
if(items.IndexOf(new_item) < 0)
items.add(new_item)
.Net 2.0中的另一种方式
static void Main(string[] args)
{
List<string> alpha = new List<string>();
for(char a = 'a'; a <= 'd'; a++)
{
alpha.Add(a.ToString());
alpha.Add(a.ToString());
}
Console.WriteLine("Data :");
alpha.ForEach(delegate(string t) { Console.WriteLine(t); });
alpha.ForEach(delegate (string v)
{
if (alpha.FindAll(delegate(string t) { return t == v; }).Count > 1)
alpha.Remove(v);
});
Console.WriteLine("Unique Result :");
alpha.ForEach(delegate(string t) { Console.WriteLine(t);});
Console.ReadKey();
}
有很多方法可以解决 - 列表中的重复问题，下面是其中之一：
List<Container> containerList = LoadContainer();//Assume it has duplicates
List<Container> filteredList = new List<Container>();
foreach (var container in containerList)
{
Container duplicateContainer = containerList.Find(delegate(Container checkContainer)
{ return (checkContainer.UniqueId == container.UniqueId); });
//Assume 'UniqueId' is the property of the Container class on which u r making a search
if(!containerList.Contains(duplicateContainer) //Add object when not found in the new class object
{
filteredList.Add(container);
}
}
干杯Ravi Ganesan
如果您使用的是.Net 3+，则可以使用Linq。
List<T> withDupes = LoadSomeData();
List<T> noDupes = withDupes.Distinct().ToList();
这是一个简单的解决方案，不需要任何难以阅读的LINQ或任何先前的列表排序。
private static void CheckForDuplicateItems(List<string> items)
{
if (items == null ||
items.Count == 0)
return;
for (int outerIndex = 0; outerIndex < items.Count; outerIndex++)
{
for (int innerIndex = 0; innerIndex < items.Count; innerIndex++)
{
if (innerIndex == outerIndex) continue;
if (items[outerIndex].Equals(items[innerIndex]))
{
// Duplicate Found
}
}
}
}
David J.的答案是一个很好的方法，不需要额外的对象，排序等等。但是可以改进它：
for (int innerIndex = items.Count - 1; innerIndex > outerIndex ; innerIndex--)
因此外部循环在整个列表的顶部位于底部，但内部循环在底部“直到达到外部循环位置”。
外部循环确保处理整个列表，内部循环查找实际的重复项，这些只能在外部循环尚未处理的部分中发生。
或者如果你不想为内部循环做底部，你可以让内部循环从outerIndex + 1开始。
你可以使用Union
obj2 = obj1.Union(obj1).ToList();
如果你有两个类qazxsw poi和qazxsw poi，我们想从他们的列表中删除重复的项目
Product您必须在下面的表单中定义泛型类
Customer然后，您可以删除列表中的重复项目。
public class Product
{
public int Id { get; set; }
public string ProductName { get; set; }
}
public class Customer
{
public int Id { get; set; }
public string CustomerName { get; set; }
}
此代码删除public class ItemEqualityComparer<T> : IEqualityComparer<T> where T : class
{
private readonly PropertyInfo _propertyInfo;
public ItemEqualityComparer(string keyItem)
{
_propertyInfo = typeof(T).GetProperty(keyItem, BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public);
}
public bool Equals(T x, T y)
{
var xValue = _propertyInfo?.GetValue(x, null);
var yValue = _propertyInfo?.GetValue(y, null);
return xValue != null && yValue != null && xValue.Equals(yValue);
}
public int GetHashCode(T obj)
{
var propertyValue = _propertyInfo.GetValue(obj, null);
return propertyValue == null ? 0 : propertyValue.GetHashCode();
}
}
的重复项目，如果你想删除其他属性的重复项目，你可以更改var products = new List<Product>
{
new Product{ProductName = "product 1" ,Id = 1,},
new Product{ProductName = "product 2" ,Id = 2,},
new Product{ProductName = "product 2" ,Id = 4,},
new Product{ProductName = "product 2" ,Id = 4,},
};
var productList = products.Distinct(new ItemEqualityComparer<Product>(nameof(Product.Id))).ToList();
var customers = new List<Customer>
{
new Customer{CustomerName = "Customer 1" ,Id = 5,},
new Customer{CustomerName = "Customer 2" ,Id = 5,},
new Customer{CustomerName = "Customer 2" ,Id = 5,},
new Customer{CustomerName = "Customer 2" ,Id = 5,},
};
var customerList = customers.Distinct(new ItemEqualityComparer<Customer>(nameof(Customer.Id))).ToList();
相同的Id然后删除重复的项目由nameof(YourClass.DuplicateProperty)属性。
nameof(Customer.CustomerName)一个简单直观的实现：
CustomerName所有答案都复制列表，或创建新列表，或使用慢速功能，或者只是非常缓慢。
根据我的理解，这是我所知道的最快和最便宜的方法（同样，由经验丰富的实时物理优化程序员支持）。
public static void RemoveDuplicates<T>(IList<T> list )
{
if (list == null)
{
return;
}
int i = 1;
while(i<list.Count)
{
int j = 0;
bool remove = false;
while (j < i && !remove)
{
if (list[i].Equals(list[j]))
{
remove = true;
}
j++;
}
if (remove)
{
list.RemoveAt(i);
}
else
{
i++;
}
}
}
最终费用是：
nlogn + n + nlogn = n + 2nlogn = O（nlogn）非常好。
关于RemoveRange的注意事项：由于我们无法设置列表的计数并避免使用Remove funcions，我不确切知道此操作的速度，但我想这是最快的方法。
怎么样：-
var noDupes = list.Distinct().ToList();
在.net 3.5？
只需使用相同类型的List初始化HashSet：
var noDupes = new HashSet<T>(withDupes);
或者，如果您想要返回List：
var noDupsList = new HashSet<T>(withDupes).ToList();
对它进行排序，然后检查彼此旁边的两个和两个，因为重复项将聚集在一起。
像这样的东西：
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--;
}
笔记：
它对我有用。简单地用
List<Type> liIDs = liIDs.Distinct().ToList<Type>();
将“类型”替换为您想要的类型，例如INT。
我喜欢用这个命令：
List<Store> myStoreList = Service.GetStoreListbyProvince(provinceId)
.GroupBy(s => s.City)
.Select(grp => grp.FirstOrDefault())
.OrderBy(s => s.City)
.ToList();
我在列表中有这些字段：Id，StoreName，City，PostalCode我想在下拉列表中显示具有重复值的城市列表。解决方案：逐个城市然后选择第一个列表。
我希望它有帮助:)
正如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()和这个样本一样）通常比从中删除项目要快得多。
扩展方法可能是一个不错的方式...这样的事情：
public static List<T> Deduplicate<T>(this List<T> listToDeduplicate)
{
return listToDeduplicate.Distinct().ToList();
}
然后像这样打电话，例如：
List<int> myFilteredList = unfilteredList.Deduplicate();