दिलचस्प पोस्ट
विंडोज के लिए एक्सएम्पीपी में PHP का उन्नयन? <div> में <tr>: क्या यह सही है? Django REST फ्रेमवर्क अपलोड छवि: "सबमिट किया गया डेटा एक फ़ाइल नहीं था" नेस्टेड जावास्क्रिप्ट ऑब्जेक्ट्स के माध्यम से विस्फोट एक अनिर्धारित संदर्भ / अनसुलझे बाहरी प्रतीक त्रुटि क्या है और मैं इसे कैसे ठीक कर सकता हूं? स्मृति से बाहर Image.FromFile जावा में NullPointerException से बचें एक कॉलम एक चेकबॉक्स बनाओ IE9 + रिचफ़ैसेस प्रतिपादन समस्या डेटाबेस में mysqldb के माध्यम से पांडा डेटाफ्रेम कैसे सम्मिलित करें? एंड्रॉइड मास्क बिटमैप कैनवास जीन पर ब्लैक स्पेस मावेन को इतना बुरा प्रतिनिधि क्यों है? जनरेटर v5 UUID नाम और नाम स्थान क्या है? UIWebView का उपयोग करके HTML कोड से उद्देश्य सी कोड में विधि डालें मैं नए C # class / इंटरफ़ेस के लिए विजुअल स्टूडियो टेम्पलेट कैसे संपादित करूं?

डुप्लिकेट्स को सूची से <T> सी # में हटाएं

सी # में एक जेनेरिक सूची को डुप्लिकेट करने के लिए किसी के पास त्वरित तरीका है?

Solutions Collecting From Web of "डुप्लिकेट्स को सूची से <T> सी # में हटाएं"

शायद आपको हैशसेट का उपयोग करने पर विचार करना चाहिए

एमएसडीएन लिंक से:

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 } */ 

यदि आप .Net 3+ का उपयोग कर रहे हैं, तो आप Linq का उपयोग कर सकते हैं।

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

कैसा रहेगा:-

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

शुद्ध 3.5 में?

बस एक ही प्रकार की सूची के साथ एक हैशसेट प्रारंभ करें:

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

या, यदि आप एक सूची लौटाना चाहते हैं:

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

इसे सॉर्ट करें, फिर एक दूसरे के बगल में दो और दो की जांच करें, क्योंकि डुप्लिकेट एक साथ दबाना होगा।

कुछ इस तरह:

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

यह मेरे लिए काम किया बस का उपयोग करें

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

अपने इच्छित प्रकार जैसे "int" को बदलें। Int

जैसा कि क्रोनोज ने 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<Store> myStoreList = Service.GetStoreListbyProvince(provinceId) .GroupBy(s => s.City) .Select(grp => grp.FirstOrDefault()) .OrderBy(s => s.City) .ToList(); 

मेरे पास ये फ़ील्ड मेरी सूची में हैं: आईडी, स्टोरनाम, सिटी, पोस्टलकोड मैं एक ड्रॉपडाउन में शहरों की सूची दिखाना चाहता था जिसमें डुप्लिकेट वैल्यू है I समाधान: शहर से समूह तब सूची के लिए पहले एक चुनें।

मुझे उम्मीद है यह मदद करेगा 🙂

एक एक्सटेंशन विधि जाने का एक अच्छा तरीका हो सकता है … ऐसा कुछ:

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

और फिर इस तरह कॉल करें, उदाहरण के लिए:

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

जावा में (मुझे लगता है कि सी # अधिक या कम समान है):

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

यदि आप वाकई मूल सूची को बदलना चाहते थे:

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

आदेश को सुरक्षित रखने के लिए, बस HansSet को LinkedHashSet के साथ बदलें

एक सहायक विधि के रूप में (बिना Linq):

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

यदि आप ऑर्डर के बारे में कोई परवाह नहीं करते हैं, तो आप आइटम को एक HashSet में ले जा सकते हैं, यदि आप आदेश को बनाए रखना चाहते हैं तो आप ऐसा कुछ कर सकते हैं:

 var unique = new List<T>(); var hs = new HashSet<T>(); foreach (T t in list) if (hs.Add(t)) unique.Add(t); 

या लिंक रास्ता:

 var hs = new HashSet<T>(); list.All( x => hs.Add(x) ); 

संपादित करें: HashSet विधि O(N) समय और O(N) अंतरिक्ष सॉर्ट करते हुए और फिर अद्वितीय (जैसा कि @ लास्सेक और अन्य द्वारा सुझाया गया है) O(N*lgN) समय और O(1) स्थान है, इसलिए ऐसा नहीं है मुझे स्पष्ट करें (जैसा कि यह पहली नज़र में था) कि छंटाई का रास्ता नीचा है (अस्थायी नीचे वोट के लिए मेरी माफ़ी …)

आस-पास डुप्लिकेट्स इन-सीटू को हटाने के लिए यहां एक एक्सटेंशन विधि है। कॉल सॉर्ट करें () पहले और एक ही आईकॉम्पियरर में पास करें यह Lasse V. Karlsen के संस्करण की तुलना में अधिक कुशल होना चाहिए जो कि बार-बार निकाला जाता है (जिसके परिणामस्वरूप एकाधिक ब्लॉक मेमोरी चालें होती हैं)।

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

यह सुनिश्चित करने के लिए आसान हो सकता है कि डुप्लिकेट सूची में नहीं जोड़े गए हैं

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

नेट 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 ur making a search if(!containerList.Contains(duplicateContainer) //Add object when not found in the new class object { filteredList.Add(container); } } 

चीयर्स रवि गणेशन

Nuget के माध्यम से अधिक LINQ पैकेज को स्थापित करना, आप एक संपत्ति द्वारा आसानी से अलग ऑब्जेक्ट सूची कर सकते हैं

 IEnumerable<Catalouge> distinctCatalouges = catalouges.DistinctBy(c => c.CatalougeCode); 

यहां एक सरल समाधान है जिसे किसी भी कठिन-से-पढ़ने वाली 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 } } } } 

डेविड जे का जवाब एक अच्छा तरीका है, अतिरिक्त वस्तुओं की आवश्यकता नहीं है, सॉर्टिंग आदि। हालांकि इसे सुधार किया जा सकता है:

for (int innerIndex = items.Count - 1; innerIndex > outerIndex ; innerIndex--)

तो बाहरी लूप पूरी सूची के लिए ऊपर नीचे जाता है, लेकिन आंतरिक लूप "जब तक बाहरी लूप की स्थिति तक नहीं पहुंच जाती है" नीचे जाती है।

बाहरी लूप सुनिश्चित करता है कि पूरी सूची संसाधित होती है, आंतरिक पाश को वास्तविक डुप्लिकेट मिल जाता है, ये उन हिस्सों में ही हो सकते हैं जो बाहरी लूप अभी तक संसाधित नहीं हुए हैं।

या यदि आप आंतरिक पाश के लिए नीचे की तरफ नहीं करना चाहते हैं, तो आप बाहरी इंडेक्स + 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++; } } } 

आप संघ का उपयोग कर सकते हैं

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