Alguém tem um método rápido para desduplicar uma lista genérica em c #?
ICollection<MyClass> withoutDuplicates = new HashSet<MyClass>(inputList);
Alguém tem um método rápido para desduplicar uma lista genérica em c #?
ICollection<MyClass> withoutDuplicates = new HashSet<MyClass>(inputList);
Respostas:
Talvez você deva considerar o uso de um HashSet .
No link 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 }
*/
HashSet
não possui um índice , portanto, nem sempre é possível usá-lo. Eu tenho que criar uma vez uma lista enorme sem duplicatas e usá-lo ListView
no modo virtual. Foi super rápido fazer o HashSet<>
primeiro e depois convertê-lo em um List<>
(assim é ListView
possível acessar itens por índice). List<>.Contains()
é muito lento.
Se você estiver usando o .Net 3+, poderá usar o Linq.
List<T> withDupes = LoadSomeData();
List<T> noDupes = withDupes.Distinct().ToList();
E se:
var noDupes = list.Distinct().ToList();
No .net 3.5?
Basta inicializar um HashSet com uma lista do mesmo tipo:
var noDupes = new HashSet<T>(withDupes);
Ou, se você deseja que uma lista seja retornada:
var noDupsList = new HashSet<T>(withDupes).ToList();
List<T>
usar como resultadonew HashSet<T>(withDupes).ToList()
Classifique-o e marque dois e dois ao lado do outro, pois as duplicatas se agruparão.
Algo assim:
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--;
}
Notas:
RemoveAt
é uma operação muito cara em umList
Eu gosto de usar este comando:
List<Store> myStoreList = Service.GetStoreListbyProvince(provinceId)
.GroupBy(s => s.City)
.Select(grp => grp.FirstOrDefault())
.OrderBy(s => s.City)
.ToList();
Eu tenho esses campos na minha lista: Id, StoreName, City, PostalCode Eu queria mostrar a lista de cidades em um menu suspenso que possui valores duplicados. solução: agrupe por cidade e escolha o primeiro da lista.
Espero que ajude :)
Funcionou para mim. simplesmente use
List<Type> liIDs = liIDs.Distinct().ToList<Type>();
Substitua "Type" pelo tipo desejado, por exemplo, int.
Como o kronoz disse no .Net 3.5, você pode usar Distinct()
.
No .Net 2 você pode imitá-lo:
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;
}
Isso pode ser usado para desduplicar qualquer coleção e retornará os valores na ordem original.
Normalmente, é muito mais rápido filtrar uma coleção (como ambos Distinct()
e esta amostra) do que seria remover itens dela.
HashSet
construtor foi deduplicado, o que o torna melhor para a maioria das circunstâncias. No entanto, isso preservaria a ordem de classificação, que HashSet
não é.
Dictionary<T, object>
vez, substituir .Contains
com .ContainsKey
e .Add(item)
com.Add(item, null)
HashSet
preserva a ordem, enquanto Distinct()
não.
Um método de extensão pode ser uma maneira decente de seguir ... algo como isto:
public static List<T> Deduplicate<T>(this List<T> listToDeduplicate)
{
return listToDeduplicate.Distinct().ToList();
}
E então chame assim, por exemplo:
List<int> myFilteredList = unfilteredList.Deduplicate();
Em Java (presumo que o C # seja mais ou menos idêntico):
list = new ArrayList<T>(new HashSet<T>(list))
Se você realmente deseja alterar a lista original:
List<T> noDupes = new ArrayList<T>(new HashSet<T>(list));
list.clear();
list.addAll(noDupes);
Para preservar a ordem, basta substituir o HashSet por LinkedHashSet.
var noDupes = new HashSet<T>(list); list.Clear(); list.AddRange(noDupes);
:)
Isso leva distintos (os elementos sem duplicar elementos) e converte-os em uma lista novamente:
List<type> myNoneDuplicateValue = listValueWithDuplicate.Distinct().ToList();
Use o método Union do Linq .
Nota: Esta solução não requer conhecimento do Linq, além do que existe.
Código
Comece adicionando o seguinte ao topo do seu arquivo de turma:
using System.Linq;
Agora, você pode usar o seguinte para remover duplicatas de um objeto chamado obj1
:
obj1 = obj1.Union(obj1).ToList();
Nota: Renomeie obj1
para o nome do seu objeto.
Como funciona
O comando União lista uma de cada entrada de dois objetos de origem. Como obj1 são os dois objetos de origem, isso reduz o obj1 a uma de cada entrada.
O ToList()
retorna uma nova lista. Isso é necessário, porque os comandos do Linq Union
retornam o resultado como um resultado IEnumerable em vez de modificar a lista original ou retornar uma nova lista.
Como método auxiliar (sem Linq):
public static List<T> Distinct<T>(this List<T> list)
{
return (new HashSet<T>(list)).ToList();
}
Se você não se preocupam com a ordem que você pode apenas empurrar os itens em um HashSet
, se você não quiser manter a ordem que você pode fazer algo como isto:
var unique = new List<T>();
var hs = new HashSet<T>();
foreach (T t in list)
if (hs.Add(t))
unique.Add(t);
Ou a maneira Linq:
var hs = new HashSet<T>();
list.All( x => hs.Add(x) );
Edit: O HashSet
método é O(N)
tempo e O(N)
espaço ao classificar e, em seguida, tornar único (como sugerido por @ lassevk e outros) é O(N*lgN)
tempo e O(1)
espaço, então não está tão claro para mim (como era à primeira vista) que a forma de classificação é inferior (minha desculpas pelo voto temporário encerrado ...)
Aqui está um método de extensão para remover duplicatas adjacentes in situ. Chame Sort () primeiro e passe no mesmo IComparer. Isso deve ser mais eficiente que a versão de Lasse V. Karlsen, que chama RemoveAt repetidamente (resultando em vários movimentos da memória do bloco).
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);
}
Pode ser mais fácil simplesmente garantir que duplicatas não sejam adicionadas à lista.
if(items.IndexOf(new_item) < 0)
items.add(new_item)
List<T>.Contains
método todas as vezes, mas com mais de 1.000.000 de entradas. Esse processo atrasa meu aplicativo. Estou usando uma List<T>.Distinct().ToList<T>()
primeira vez.
Outra maneira no .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();
}
Há muitas maneiras de resolver - a questão das duplicatas na lista, abaixo é uma delas:
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);
}
}
Felicidades Ravi Ganesan
Aqui está uma solução simples que não requer nenhum LINQ difícil de ler ou qualquer classificação prévia da lista.
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
}
}
}
}
A resposta de David J. é um bom método, sem necessidade de objetos extras, classificação, etc. No entanto, pode ser aprimorado:
for (int innerIndex = items.Count - 1; innerIndex > outerIndex ; innerIndex--)
Portanto, o loop externo fica no topo da parte inferior da lista inteira, mas o loop interno fica no fundo "até que a posição do loop externo seja atingida".
O loop externo assegura que toda a lista seja processada, o loop interno encontra as duplicatas reais, elas só podem acontecer na parte que o loop externo ainda não processou.
Ou, se você não quiser fazer de baixo para cima para o loop interno, poderá iniciar o loop interno em outerIndex + 1.
Todas as respostas copiam listas, ou criam uma nova lista, ou usam funções lentas, ou são extremamente lentas.
Na minha opinião, esse é o método mais rápido e mais barato que conheço (também apoiado por um programador muito experiente, especializado em otimização física em tempo real).
// 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();
O custo final é:
nlogn + n + nlogn = n + 2nlogn = O (nlogn), o que é bastante agradável.
Nota sobre o RemoveRange: Como não podemos definir a contagem da lista e evitar o uso das funções Remover, não sei exatamente a velocidade dessa operação, mas acho que é a maneira mais rápida.
Se você tem aulas de reboque Product
e Customer
queremos remover itens duplicados da lista
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; }
}
Você deve definir uma classe genérica no formulário abaixo
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();
}
}
Você pode remover itens duplicados da sua lista.
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();
esse código remove itens duplicados por Id
se você deseja remover itens duplicados por outra propriedade, você pode alterar o nameof(YourClass.DuplicateProperty)
mesmo nameof(Customer.CustomerName)
e remover itens duplicados por CustomerName
Propriedade.
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++;
}
}
}
Uma implementação intuitiva simples:
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;
}