Quelqu'un a-t-il une méthode rapide pour dédupliquer une liste générique en C #?
ICollection<MyClass> withoutDuplicates = new HashSet<MyClass>(inputList);
Quelqu'un a-t-il une méthode rapide pour dédupliquer une liste générique en C #?
ICollection<MyClass> withoutDuplicates = new HashSet<MyClass>(inputList);
Réponses:
Vous devriez peut-être envisager d'utiliser un HashSet .
À partir du lien 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'a pas d'index , il n'est donc pas toujours possible de l'utiliser. Je dois créer une fois une énorme liste sans doublons, puis l'utiliser pour ListView
le mode virtuel. Il était super rapide de faire une HashSet<>
première, puis de la convertir en un List<>
(donc ListView
on peut accéder aux éléments par index). List<>.Contains()
est trop lent.
Si vous utilisez .Net 3+, vous pouvez utiliser Linq.
List<T> withDupes = LoadSomeData();
List<T> noDupes = withDupes.Distinct().ToList();
Que diriez-vous:
var noDupes = list.Distinct().ToList();
Dans .net 3.5?
Initialisez simplement un HashSet avec une liste du même type:
var noDupes = new HashSet<T>(withDupes);
Ou, si vous souhaitez renvoyer une liste:
var noDupsList = new HashSet<T>(withDupes).ToList();
List<T>
utilisation en conséquencenew HashSet<T>(withDupes).ToList()
Triez-le, puis cochez deux et deux côte à côte, car les doublons s'agglutineront.
Quelque chose comme ça:
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--;
}
Remarques:
RemoveAt
est une opération très coûteuse sur unList
J'aime utiliser cette commande:
List<Store> myStoreList = Service.GetStoreListbyProvince(provinceId)
.GroupBy(s => s.City)
.Select(grp => grp.FirstOrDefault())
.OrderBy(s => s.City)
.ToList();
J'ai ces champs dans ma liste: Id, StoreName, City, PostalCode Je voulais afficher la liste des villes dans une liste déroulante qui a des valeurs en double. solution: Groupez par ville puis choisissez le premier pour la liste.
J'espère que ça aide :)
Ça a marché pour moi. utilisez simplement
List<Type> liIDs = liIDs.Distinct().ToList<Type>();
Remplacez "Type" par le type souhaité, par exemple int.
Comme l'a dit kronoz dans .Net 3.5, vous pouvez utiliser Distinct()
.
Dans .Net 2, vous pouvez l'imiter:
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;
}
Cela pourrait être utilisé pour dédupliquer n'importe quelle collection et retournera les valeurs dans l'ordre d'origine.
Il est normalement beaucoup plus rapide de filtrer une collection (comme le font les deux Distinct()
et cet exemple) que de supprimer des éléments de celle-ci.
HashSet
constructeur avait détruit, ce qui le rend meilleur dans la plupart des cas. Cependant, cela conserverait l'ordre de tri, ce qui HashSet
n'est pas le cas.
Dictionary<T, object>
place, remplacer .Contains
par .ContainsKey
et .Add(item)
avec.Add(item, null)
HashSet
préserve l'ordre alors Distinct()
que non.
Une méthode d'extension pourrait être une bonne façon de procéder ... quelque chose comme ceci:
public static List<T> Deduplicate<T>(this List<T> listToDeduplicate)
{
return listToDeduplicate.Distinct().ToList();
}
Et puis appelez comme ceci, par exemple:
List<int> myFilteredList = unfilteredList.Deduplicate();
En Java (je suppose que C # est plus ou moins identique):
list = new ArrayList<T>(new HashSet<T>(list))
Si vous vouliez vraiment muter la liste originale:
List<T> noDupes = new ArrayList<T>(new HashSet<T>(list));
list.clear();
list.addAll(noDupes);
Pour préserver l'ordre, remplacez simplement HashSet par LinkedHashSet.
var noDupes = new HashSet<T>(list); list.Clear(); list.AddRange(noDupes);
:)
Cela prend des éléments distincts (les éléments sans éléments en double) et les convertit à nouveau en liste:
List<type> myNoneDuplicateValue = listValueWithDuplicate.Distinct().ToList();
Utilisez la méthode Union de Linq .
Remarque: Cette solution ne nécessite aucune connaissance de Linq, à part qu'elle existe.
Code
Commencez par ajouter ce qui suit en haut de votre fichier de classe:
using System.Linq;
Maintenant, vous pouvez utiliser ce qui suit pour supprimer les doublons d'un objet appelé obj1
:
obj1 = obj1.Union(obj1).ToList();
Remarque: Renommez obj1
le nom de votre objet.
Comment ça fonctionne
La commande Union répertorie une entrée de chaque entrée de deux objets source. Étant donné que obj1 est les deux objets source, cela réduit obj1 à l'une de chaque entrée.
La ToList()
renvoie une nouvelle liste. Cela est nécessaire, car les commandes Linq comme Union
renvoie le résultat en tant que résultat IEnumerable au lieu de modifier la liste d'origine ou de renvoyer une nouvelle liste.
Comme méthode d'assistance (sans Linq):
public static List<T> Distinct<T>(this List<T> list)
{
return (new HashSet<T>(list)).ToList();
}
Si vous ne se soucient pas de l'ordre que vous pouvez juste pousser les éléments dans un HashSet
, si vous ne voulez maintenir l'ordre que vous pouvez faire quelque chose comme ceci:
var unique = new List<T>();
var hs = new HashSet<T>();
foreach (T t in list)
if (hs.Add(t))
unique.Add(t);
Ou à la manière Linq:
var hs = new HashSet<T>();
list.All( x => hs.Add(x) );
Edit: La HashSet
méthode est le O(N)
temps et l' O(N)
espace tout en triant puis en rendant unique (comme suggéré par @ lassevk et d'autres) est le O(N*lgN)
temps et l' O(1)
espace donc il n'est pas si clair pour moi (comme c'était à première vue) que le mode de tri est inférieur (mon excuses pour le vote temporaire de baisse ...)
Voici une méthode d'extension pour supprimer les doublons adjacents in situ. Appelez d'abord Sort () et passez le même IComparer. Cela devrait être plus efficace que la version de Lasse V. Karlsen qui appelle RemoveAt à plusieurs reprises (entraînant plusieurs mouvements de mémoire de bloc).
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);
}
Il pourrait être plus facile de simplement s'assurer que les doublons ne sont pas ajoutés à la liste.
if(items.IndexOf(new_item) < 0)
items.add(new_item)
List<T>.Contains
méthode à chaque fois mais avec plus de 1 000 000 d'entrées. Ce processus ralentit ma candidature. J'utilise une List<T>.Distinct().ToList<T>()
première à la place.
Une autre façon dans .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();
}
Il existe de nombreuses façons de résoudre le problème des doublons dans la liste ci-dessous:
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);
}
}
Bravo Ravi Ganesan
Voici une solution simple qui ne nécessite aucun LINQ difficile à lire ni aucun tri préalable de la liste.
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
}
}
}
}
La réponse de David J. est une bonne méthode, pas besoin d'objets supplémentaires, de tri, etc. Elle peut cependant être améliorée:
for (int innerIndex = items.Count - 1; innerIndex > outerIndex ; innerIndex--)
Ainsi, la boucle externe va en haut en bas pour toute la liste, mais la boucle interne va en bas "jusqu'à ce que la position de la boucle externe soit atteinte".
La boucle externe s'assure que toute la liste est traitée, la boucle interne trouve les doublons réels, ceux-ci ne peuvent se produire que dans la partie que la boucle externe n'a pas encore traitée.
Ou si vous ne voulez pas faire de bas en haut pour la boucle intérieure, vous pouvez faire démarrer la boucle intérieure à externalIndex + 1.
Toutes les réponses copient des listes, ou créent une nouvelle liste, ou utilisent des fonctions lentes, ou sont tout simplement douloureusement lentes.
À ma connaissance, c'est la méthode la plus rapide et la moins chère que je connaisse (également, soutenue par un programmeur très expérimenté spécialisé dans l'optimisation physique en temps réel).
// 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();
Le coût final est:
nlogn + n + nlogn = n + 2nlogn = O (nlogn) ce qui est plutôt sympa.
Remarque sur RemoveRange: Étant donné que nous ne pouvons pas définir le nombre de la liste et éviter d'utiliser les fonctions Remove, je ne connais pas exactement la vitesse de cette opération, mais je suppose que c'est le moyen le plus rapide.
Si vous avez des classes de remorquage Product
et Customer
que nous voulons supprimer les éléments en double de leur liste
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; }
}
Vous devez définir une classe générique dans le formulaire ci-dessous
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();
}
}
vous pouvez ensuite supprimer les éléments en double de votre liste.
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();
supprimer ce code doublons par Id
si vous voulez supprimer les doublons par d' autres biens, vous pouvez modifier nameof(YourClass.DuplicateProperty)
même nameof(Customer.CustomerName)
supprimer les doublons puis par la CustomerName
propriété.
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++;
}
}
}
Une implémentation simple et intuitive:
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;
}