从列表中删除重复项在c#中

把它排序，然后检查两个和两个相邻的，因为重复的会聚集在一起。

就像这样:

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#值元组来进行交换，如果你不能使用它，可以用适当的代码来代替
• 最终结果不再排序

也许您应该考虑使用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);

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

如果你不关心顺序，你可以把项目推到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)空间，所以我不太清楚(因为它是第一眼)，排序方式是低劣的

如何:

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

在。net 3.5?

如果你使用。net 3+，你可以使用Linq。

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

正如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()和这个示例都是这样做的)比从其中删除项目要快得多。

简单地用相同类型的List初始化HashSet:

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

或者，如果你想返回一个List:

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

扩展方法可能是一种不错的方式……就像这样:

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

然后像这样调用，例如:

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

在。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();
}

这里有一个扩展的方法来删除相邻的副本原位。首先调用Sort()并传入相同的ic比较器。这应该比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);
}

有很多方法可以解决列表中的重复问题，下面是其中之一:

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

这里有一个简单的解决方案，不需要任何难读的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
}
}
}
}

可能更简单的方法是确保没有将重复项添加到列表中。

if(items.IndexOf(new_item) < 0)
items.add(new_item)

我喜欢使用这个命令:

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

这对我很管用。简单地使用

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

将“类型”替换为所需的类型，例如int。

David J。的答案是一个很好的方法，不需要额外的对象，排序等。但是，它可以在以下方面进行改进:

# EYZ0

因此，对于整个列表，外部循环会从上到下，但内部循环会从下到“直到到达外部循环的位置”。

外部循环确保整个列表被处理，内部循环找到实际的重复项，这些只会发生在外部循环还没有处理的部分。

或者如果你不想对内循环做自底向上你可以让内循环从outerIndex + 1开始。

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

作为一个辅助方法(没有Linq):

public static List<T> Distinct<T>(this List<T> list)
{
return (new HashSet<T>(list)).ToList();
}

通过Nuget安装MoreLINQ包，你可以很容易地通过属性区分对象列表

IEnumerable<Catalogue> distinctCatalogues = catalogues.DistinctBy(c => c.CatalogueCode);

你可以使用Union

obj2 = obj1.Union(obj1).ToList();

使用Linq的联盟方法。

注意:这个解决方案不需要了解Linq，只需要知道它存在。

代码

首先将以下内容添加到类文件的顶部:

using System.Linq;

现在，你可以使用下面的方法从一个名为obj1的对象中删除重复项:

obj1 = obj1.Union(obj1).ToList();

注意:将obj1重命名为对象的名称。

它是如何工作的

1. Union命令列出两个源对象的每个条目中的一个。由于obj1都是源对象，这将把obj1减少为每个条目中的一个。

2. ToList()返回一个新的List。这是必要的，因为像Union这样的Linq命令将结果返回为IEnumerable结果，而不是修改原始List或返回一个新的List。

一个简单直观的实现:

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

如果你有两个类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属性删除重复项。

这将使用distinct(没有重复元素的元素)并再次将其转换为列表:

List<type> myNoneDuplicateValue = listValueWithDuplicate.Distinct().ToList();

所有的答案要么复制列表，要么创建一个新列表，要么使用慢函数，要么就是慢得令人痛苦。

根据我的理解，这是我所知道的最快和最便宜的方法(同时，由一个非常有经验的实时物理优化程序员支持)。

// Duplicates will be noticed after a sort O(nLogn)
list.Sort();


// Store the current and last items. Current item declaration is not really needed, and probably optimized by the compiler, but in case it's not...
int lastItem = -1;
int currItem = -1;


int size = list.Count;


// Store the index pointing to the last item we want to keep in the list
int last = size - 1;


// Travel the items from last to first O(n)
for (int i = last; i >= 0; --i)
{
currItem = list[i];


// If this item was the same as the previous one, we don't want it
if (currItem == lastItem)
{
// Overwrite last in current place. It is a swap but we don't need the last
list[i] = list[last];


// Reduce the last index, we don't want that one anymore
last--;
}


// A new item, we store it and continue
else
lastItem = currItem;
}


// We now have an unsorted list with the duplicates at the end.


// Remove the last items just once
list.RemoveRange(last + 1, size - last - 1);


// Sort again O(n logn)
list.Sort();

最终成本为:

nlogn + n + nlogn = n + 2nlogn = O (nlogn)这很好。

关于RemoveRange的说明: 由于我们不能设置列表的计数并避免使用Remove函数，我不知道这个操作的确切速度，但我猜这是最快的方法。< / p >

我认为最简单的方法是:

创建一个新列表并添加唯一的项目。

例子:

        class MyList{
int id;
string date;
string email;
}
    

List<MyList> ml = new Mylist();


ml.Add(new MyList(){
id = 1;
date = "2020/09/06";
email = "zarezadeh@gmailcom"
});


ml.Add(new MyList(){
id = 2;
date = "2020/09/01";
email = "zarezadeh@gmailcom"
});


List<MyList> New_ml = new Mylist();


foreach (var item in ml)
{
if (New_ml.Where(w => w.email == item.email).SingleOrDefault() == null)
{
New_ml.Add(new MyList()
{
id = item.id,
date = item.date,
email = item.email
});
}
}

使用< >强HashSet < / >强可以很容易地做到这一点。

List<int> listWithDuplicates = new List<int> { 1, 2, 1, 2, 3, 4, 5 };
HashSet<int> hashWithoutDuplicates = new HashSet<int> ( listWithDuplicates );
List<int> listWithoutDuplicates = hashWithoutDuplicates.ToList();

根据删除重复，我们必须应用下面的逻辑，所以它将以快速的方式删除重复。

public class Program
{


public static void Main(string[] arges)
{
List<string> cities = new List<string>() { "Chennai", "Kolkata", "Mumbai", "Mumbai","Chennai", "Delhi", "Delhi", "Delhi", "Chennai", "Kolkata", "Mumbai", "Chennai" };
cities = RemoveDuplicate(cities);


foreach (var city in cities)
{
Console.WriteLine(city);
}
}


public static List<string> RemoveDuplicate(List<string> cities)
{
if (cities.Count < 2)
{
return cities;
}


int size = cities.Count;
for (int i = 0; i < size; i++)
{
for (int j = i+1; j < size; j++)
{
if (cities[i] == cities[j])
{
cities.RemoveAt(j);
size--;
j--;
}
}
}
return cities;
}
}

如果需要比较复杂的对象，则需要在Distinct()方法中传递一个compararer对象。

private void GetDistinctItemList(List<MyListItem> _listWithDuplicates)
{
//It might be a good idea to create MyListItemComparer
//elsewhere and cache it for performance.
List<MyListItem> _listWithoutDuplicates = _listWithDuplicates.Distinct(new MyListItemComparer()).ToList();
        

//Choose the line below instead, if you have a situation where there is a chance to change the list while Distinct() is running.
//ToArray() is used to solve "Collection was modified; enumeration operation may not execute" error.
//List<MyListItem> _listWithoutDuplicates = _listWithDuplicates.ToArray().Distinct(new MyListItemComparer()).ToList();


return _listWithoutDuplicates;
}

假设你有另外两个类，比如:

public class MyListItemComparer : IEqualityComparer<MyListItem>
{
public bool Equals(MyListItem x, MyListItem y)
{
return x != null
&& y != null
&& x.A == y.A
&& x.B.Equals(y.B);
&& x.C.ToString().Equals(y.C.ToString());
}


public int GetHashCode(MyListItem codeh)
{
return codeh.GetHashCode();
}
}

和:

public class MyListItem
{
public int A { get; }
public string B { get; }
public MyEnum C { get; }


public MyListItem(int a, string b, MyEnum c)
{
A = a;
B = b;
C = c;
}
}

我有我自己的方式。我是2循环相同的列表比较列表项。然后去掉第二个。

            for(int i1 = 0; i1 < lastValues.Count; i1++)
{
for(int i2 = 0; i2 < lastValues.Count; i2++)
{
if(lastValues[i1].UserId == lastValues[i2].UserId)
{
lastValues.RemoveAt(i2);
}
}
}