c# List去重

c# List去重需求:对List集合中的元素去重。实现:有三种方式可以使用-使用Linq中distinct()方法-借助hashset-使用for循环遍历,这种方法在数据量大时,运行速度比较慢代码示例使用distinct()//使用distinct()List<string>lst1=newList<string>(){“as”,”lio”,”sdrf”,”asd”,”lio”};varr.

大家好,又见面了,我是你们的朋友全栈君。

  1. 需求 : 对List集合中的元素去重。
  2. 实现: 有三种方式可以使用
    – 使用Linq中distinct()方法
    – 借助hashset
    – 使用for循环遍历,这种方法在数据量大时,运行速度比较慢

代码示例

  • 使用distinct()

  //使用distinct()
  List<string> lst1 = new List<string>() 
  { 
    "as", "lio", "sdrf", "asd", "lio" };
            var  reslst =lst1.Distinct().ToList();
  • 使用hashset

 public static List<T> RemoveT<T>(List<T> items)
        { 
   
            HashSet<T> set = new HashSet<T>();

            var res = new List<T>();//返回

            for (int i = 0; i < items.Count; i++)
            { 
   
                if (!set.Contains(items[i]))
                { 
   
                    set.Add(items[i]);
                    res.Add(items[i]);
                }
            }
            return res;
        }
  • 使用for-loop

 public  static List<string> ForLoopRemove(List<string> items)
        { 
   
            List<string> output = new List<string>();
            for (int i = 0; i < items.Count; i++)
            { 
   
                bool flag = false;
                //每个元素都与其他这个元素前面的比较,如果前面没有,则添加,否则不添加
                for (int z = 0; z < i; z++)
                { 
   
                    if (items[z] == items[i])
                    { 
   
                        flag = true;
                        break;
                    }
                }
                if (!flag)
                { 
   
                    output.Add(items[i]);
                }
            }
            return output;
        }

测试三种方式的运行速度
代码示例

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace ConsoleApp2
{ 
   
    class Program
    { 
   
        static void Main(string[] args)
        { 
   
            //list 去重,三种方法
            for (int test = 0; test < 3; test++)
            { 
   
                // 获取测试数据
                var testData = GetTestData(test);
                var max = testData.Item3;///执行次数

                var s1 = Stopwatch.StartNew();
                for (int i = 0; i < max; i++)
                { 
   
                    // 方法 1: use Distinct.
                    var unique = testData.Item2.Distinct().ToList();
                }
                s1.Stop();
                var s2 = Stopwatch.StartNew();
                for (int i = 0; i < max; i++)
                { 
   
                    // 方法 2: use HashSet.
                    var unique = Method.RemoveT(testData.Item2);
                }
                s2.Stop();
                var s3 = Stopwatch.StartNew();
                for (int i = 0; i < max; i++)
                { 
   
                    // 方法 3: use nested for-loop.
                    var unique = Method.ForLoopRemove(testData.Item2);
                }
                s3.Stop();
                // 打印信息.
                Console.WriteLine(testData.Item1);
                //调用时间.
                Console.WriteLine(s1.Elapsed.TotalMilliseconds + " ms");
                Console.WriteLine(s2.Elapsed.TotalMilliseconds + " ms");
                Console.WriteLine(s3.Elapsed.TotalMilliseconds + " ms");
            }

            //结论: 当数据量少时,直接使用for-loop 遍历数据即可;
            //当数据量大时,使用hashSet 或者时linq的distinct()方法
            List<string> testLst=  GetListWithDuplicates(100, 20);
            Method.RemoveRepeat(testLst);

            //实现按照对象的某个字段去重。

            List<Student> lst = new List<Student>();
            lst.Add(new Student { 
    No = 23, name = "李磊" });
            lst.Add(new Student { 
    No = 45, name = "david" });
            lst.Add(new Student { 
    No = 12, name = "lily" });

            lst.Add(new Student { 
    No = 23, name = "李磊" });
            lst.Add(new Student { 
    No = 45, name = "david" });
            lst.Add(new Student { 
    No = 72, name = "lily" });

            var res=  lst.Distinct(new ItemEqualityComparer());
            foreach (var item in res)
            { 
   
                Console.WriteLine($"distinct: {item.No}---{item.name}");
            }


            Console.ReadKey();
        }

      

        /// <summary>
        /// 生成测试数据,最后的一个参数,表示方法被调用的次数
        /// </summary>
        /// <param name="test"></param>
        /// <returns></returns>
        static Tuple<string, List<string>, int> GetTestData(int test)
        { 
   
            // Tuple contains description string, list, the unique element count, and iterations for test.
            switch (test)
            { 
   
                default:
                case 0:
                    return new Tuple<string, List<string>, int>("10 ELEMENT LIST, 0 DUPLICATES",
                        GetListWithDuplicates(10, 0),
                        100000);
                case 1:
                    return new Tuple<string, List<string>, int>("300 ELEMENT LIST, 100 DUPLICATES",
                        GetListWithDuplicates(200, 100),
                        1000);
                case 2:
                    return new Tuple<string, List<string>, int>("3000 ELEMENT LIST, 1000 DUPLICATES",
                        GetListWithDuplicates(2000, 1000),
                        100);
            }
        }

        public static List<string> GetListWithDuplicates(int len, int repeatNum)
        { 
   
            const string duplicateString = "bird";
            List<string> result = new List<string>();
            for (int i = 0; i < len; i++)
            { 
   
                result.Add("cat" + i);

                if (repeatNum > 0)
                { 
   
                    result.Add(duplicateString);
                    repeatNum--;
                }
            }

            for (int i = 0; i < repeatNum; i++)
            { 
   
                result.Add(duplicateString);
            }
            return result;
        }
    }


    /// //
  #region 按照对象的某个字段去重
    public class Student
    { 
   
        public string name;
        public int No;
        
    }
    /// <summary>
    /// 按照学号判断
    /// </summary>
    public class ItemEqualityComparer : IEqualityComparer<Student>
    { 
   
        public bool Equals(Student x, Student y)
        { 
   
            return x.No == y.No;
        }

        public int GetHashCode(Student obj)
        { 
   
            return obj.No.GetHashCode();
        }
    }
    #endregion

}

调用方法的封装

using System;
using System.Collections.Generic;


namespace ConsoleApp2
{ 
   
    public static class Method
    { 
   

        /// <summary>
        /// 使用两个循环,但是在数据量大时,这种方法比较慢
        /// </summary>
        /// <param name="items"></param>
        /// <returns></returns>
        public  static List<string> ForLoopRemove(List<string> items)
        { 
   
            List<string> output = new List<string>();
            for (int i = 0; i < items.Count; i++)
            { 
   
                bool flag = false;
                //每个元素都与其他这个元素前面的比较,如果前面没有,则添加,否则不添加
                for (int z = 0; z < i; z++)
                { 
   
                    if (items[z] == items[i])
                    { 
   
                        flag = true;
                        break;
                    }
                }
                if (!flag)
                { 
   
                    output.Add(items[i]);
                }
            }
            return output;
        }

        /// <summary>
        /// 使用hashset去重
        /// </summary>
        /// <param name="lst"></param>
       public  static void RemoveRepeat(List<string> lst)
        { 
   
            Console.WriteLine("intput :" + lst.Count);

            HashSet<string> set = new HashSet<string>();
            foreach (string item in lst)
            { 
   
                set.Add(item);
            }
            Console.WriteLine(set.Count);

            lst.Clear();
            lst.AddRange(set);
            Console.WriteLine("outPut: "+lst.Count);
        }

        /// <summary>
        /// 使用hashset去重的泛型方法
        /// </summary>
        /// <param name="items"></param>
       public static List<T> RemoveT<T>(List<T> items)
        { 
   
            HashSet<T> set = new HashSet<T>();

            var res = new List<T>();//返回

            for (int i = 0; i < items.Count; i++)
            { 
   
                if (!set.Contains(items[i]))
                { 
   
                    set.Add(items[i]);
                    res.Add(items[i]);
                }
            }
            return res;
        }

    }
}

  • 代码中,也提供了对象集合按照对象的某个字段进行去重的方法。
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/141341.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 计算机网口在什么位置,电脑网线插路由器哪个口?

    计算机网口在什么位置,电脑网线插路由器哪个口?问:电脑网线插路由器哪个口?我的路由器上有5个接口,请问电脑用网线应该插在路由器的哪一个接口?答:普通的家用路由器上的接口有2种类型:WAN接口,LAN接口。其中WAN接口只有1个,LAN接口一般是4个(有的路由器可能只有2个、3个LAN接口)。温馨提示:WAN接口,在有的路由器中叫做:Internet接口,广域网接口等,这一点大家稍微注意一下。但绝大部分的路由器上面,标注的都是WAN接口。在安装…

  • 网站seo如何优化效果好_网站seo运营

    网站seo如何优化效果好_网站seo运营有些人会觉得,营销型网站不用做优化了,这是一个误区。就像不是所有有商城网站的公司都是电子商务公司一样,不是营销型网站就一定营销做得很好不需要优化。营销型网站优化是对营销型网站进行程序、内容、版块、布局等多方面的优化调整,也就是搜索互联网站设计时适合搜索引擎检索,满足搜索引擎排名的指标,从而在搜索引擎检索中获得NNT流量排名靠前,增强搜索引擎营销的效果使营销型网站的产品相关的关键词能有好的排位。使营…

  • python求最大公约数和最小公倍数的两种方法

    python求最大公约数和最小公倍数的两种方法最大公约数和最小公倍数的求解可以归结为求最大公约数,最小公倍数为两数乘积除以最大公倍数这里介绍两种求解方法,一种数常规易于理解的,一种是用辗转相除法实现的#求最大公倍数和最小公约数a=int(input(“输入一个数字”))b=int(input(“再输入一个数字”))m=[]ifa>b:smaller=belse:smaller=afori…

  • 什么是依赖注入

    什么是依赖注入

    2021年11月13日
  • scikit-learn代码实现SVM分类与SVR回归以及调参

    scikit-learn代码实现SVM分类与SVR回归以及调参分类二分类:fromsklearn.model_selectionimporttrain_test_splitfromsklearn.svmimportSVCimportmglearn.datasetsimportmatplotlib.pyplotasplt#forge数据集是一个二维二分类数据集X,y=mglearn.tools.make_handcraf…

    2022年10月29日
  • 用python绘制圆(python用函数绘制椭圆)

    同时需要了解Numpy和Matplotlib相关知识。看代码吧,仔细了解清楚每句代码,每个函数。#-*-coding:utf-8-*-#!python3importnumpyasnpimportmatplotlib.pyplotasplt#==========================================#圆的基本信息#1.圆半径r=2.0#2.圆…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号