精华内容
下载资源
问答
  • c#泛型集合
    2021-10-06 11:00:34

    1.List<数据类型>

    用法:当我们不知道一个类型数组的个数时,我们可以定义此。

    实例:

    创建类:
        class User
        {
            private string name;
            private string password;
            private UserLoginState userState;
    
            private User()
            {
    
            }
            public User(string name,string password,UserLoginState userState) : this()
            {
                Name = name;
                Password = password;
                UserState = userState;
            }
    
            public string Name { get; set; }
            public string Password { get; set; }
            public UserLoginState UserState { get; set; }
    
        }
    调用:
                List<User> userList1 = new List<User>();
                userList1.Add(new User("guzijian", "12345", UserLoginState.Login));
                userList1.Add(new User("guzijian1", "123456", UserLoginState.Logout));
                userList1.Add(new User("guzijian2", "123457", UserLoginState.Banned));
                userList1.Add(new User("guzijian3", "123458", UserLoginState.Admin));
                foreach(var item in userList1)
                {
                    Console.WriteLine("Name:" + item.Name + "\tPass:" + item.Password + "\tState:" + item.UserState);
                }

    其对应很多自带的方法,我们后面会说。

    2.字典集合

    当我们添加5个用户,找起来还比较方便,加入,我们添加10000个用户呢?

    这时候就要用到键值对的概念,即字典集合。

    用法:当数组体量较大,又需要在其中根据什么寻找特定的某一个元素时,可以使用此。这里我们

    实例:

                Dictionary<string,User> userDictList = new Dictionary<string, User>();
                userDictList.Add("guzijian",new User("guzijian", "12345", UserLoginState.Login));
                userDictList.Add("guzijian1", new User("guzijian1", "12346", UserLoginState.Logout));
                userDictList.Add("guzijian2", new User("guzijian2", "12347", UserLoginState.Banned));
                userDictList.Add("guzijian3", new User("guzijian3", "12348", UserLoginState.Admin));
                
                
                Console.WriteLine("Name:" + userDictList["guzijian"].Name + "\tPass:" + userDictList["guzijian"].Password + "\tState:" + (int)userDictList["guzijian"].UserState);

    字典集合和泛型集合的用处,一个是用于存储大批量的数据,但是经常使用某一个,并不像遍历;而另一个用于存储大量数据和数组类似,用到的时候,不会只用到一个,而是全部遍历。

    更多相关内容
  • 一、泛型集合List排序 经sort方法之后,采用了升序的方式进行排列的。 List<int> list = new List() { 2, 4, 1, 3, 5, -2, 0, 10 }; Console.Write("排序前..."); foreach (var item in list) { Console.Write...
  • C#泛型集合

    2019-10-09 10:00:50
    数组的局限性: ***数组元素个数是固定的,数组一但定义,就无法改变元素总数,...泛型集合的特点:元素可以摆放无序 ***<T>表示泛型,T是Type的缩写,表示当前不确定具体类型。 ***可以根据用户的实际需要...

    数组的局限性:

    ***数组元素个数是固定的,数组一但定义,就无法改变元素总数,如果需求变化,就要修改源码。

    ***如果初始化元素总数非常大,则会造成空间浪费。

    集合的特点:

    ***根据需求动态增加元素个数,没有限制。

    List<T>泛型集合的特点:元素可以摆放无序

    ***<T>表示泛型,T是Type的缩写,表示当前不确定具体类型。

    ***可以根据用户的实际需要,确立当前集合需要存放的数据类型,一但确定不可改变。

    List<T>泛型集合的存储结构:

    泛型集合要求:

    ***使用泛型集合只能添加一种类型的数据,数据取出后无需强制转换。

    List<T>使用前的准备工作:

    ***引入命名空间using System.Collections.Generic;

    ***确定存储类型:list<Student> student = new List<Student>();

    常用方法:

    ***添加元素:Add(<T>);

    ***删除元素:RemoveAt(索引)

    常用属性:

    ***元素个数:Count

    遍历集合:

    foreach(Student stu in students)
    {
        //代码段
        Console.WriteLine(stu.StudentName);
    }

    例子:

    class Program
        {
            static void Main(string[] args)
            {
                //创建对象
                Student objStudent1 = new Student(1001,"joday");
                Student objStudent2 = new Student(1002, "lucy");
                Student objStudent3 = new Student(1003, "marry");
                Student objStudent4 = new Student(1004, "Alice");
                stuList.Add(new Student() 
                { 
                    StudentId = 10006,
                    StudentName = "xiaojing"
                    
                });//初始化器
    
                //集合初始化器            
                List<Student> nameList = new List<Student>(){objStu1,objStu2,objStu3};
    
                //创建集合对象
                List<Student> stuList = new List<Student>();
                stuList.Add(objStudent1);//一个一个往集合中添加元素
                stuList.Add(objStudent2);
                stuList.Add(objStudent3);
                stuList.Add(objStudent4);
                //以数组的形式往集合中添加元素,不用一个一个添加
                //stuList.AddRange()
    
                //获取元素的个数
                Console.WriteLine("元素总数:{0}",stuList.Count);
    
                //删除元素
                stuList.Remove(objStudent2);//按元素删除
                stuList.RemoveAt(0);//按元素的索引删除
    
                //插入一个对象
                stuList.Insert(0,new Student(1006,"but"));//在所引处添加一个元素
                Console.WriteLine(objStudent1.StudentName);//get设置
    
                //遍历
                foreach(Student i in stuList)
                {
                    Console.WriteLine(i.StudentName+"\t"+i.StudentId);
                }
                Console.ReadLine();
                
            
            
    
            }

    泛型集合Dictionary<K,V>:(存储基于哈希表)元素摆放有序,通过序号K找到对象V

    ***Dictionary<K,V>通常称为字典,<K,V>约束集合中元素的类型。

    ***编译时检查类型约束,无需装箱拆箱操作,与哈希表操作类似

    Dictionary<K,V>的存储结构:

    例子:

                Dictionary<string,Student> stus = new Dictionary<string,Student>();
                stus.Add("joday", objStudent1);
                stus.Add("lucy", objStudent2);
                //取出元素
                Console.WriteLine(stus["joday"].StudentId);
    
                foreach (Student value in stus.Values) //对值遍历,键、值一次遍历只能遍历一个
                {
                    Console.WriteLine(value.StudentName +"\t"+value.StudentId);
                }
    
                foreach(string key in stus.Keys)//对键进行遍历
                {
                    Console.WriteLine(key);
                }

     

    展开全文
  • 【记录】C#泛型集合

    2021-08-20 20:37:34
    面试时不知觉的提到了泛型集合,索性记录一下 1.从数组说起数组是具有同一类型的多个对象的集合,是一种数据结构,包含同一类型的多个元素。数组是具有同一类型的多个对象的集合,是一种数据结构,包含同一类型的多...

    面试时不知觉的提到了泛型集合,索性记录一下

    1.从数组说起,数组是具有同一类型的多个对象的集合,是一种数据结构,包含同一类型的多个元素。

    •     int[] arr = new int[10];
    •     for (int i = 0; i < 10; ++i)
          {
    •        arr[i] = i;
    •     }

    var 简称为推断类型,使用var定义变量和object不同,它在效率上和使用强类型方式定义变量完全一样。

    无论何种数组类型,在C#中都是从类型System.Array继承而来。

    Array是一个抽象类,但是在程序中可以使用Array的一些方法来创建实例数组、读取或者设置值。

    Array a2 = Array.CreateInstance(typeof(string),10);
    for(int i=0;i<10;i++){
    	a2.SetValue(Convert.ToString(i), i);
    }
    注:
    SetValue为数组元素赋值,GetValue得到数组元素的值,在Array中定义了一系列重载函数用于读取/设置 值。
    
    foreach (var val in a2){
    	Console.WriteLine(val);
     }
    
    System.Collections.IEnumerator enumerator 
    			= a2.GetEnumerator();
    while (enumerator.MoveNext()){
    	Console.WriteLine(enumerator.Current);
    }
    

    所以集合是.NET FCL(Framework Class Library)中很重要的一部分。下图是FCL中集合实现的接口。

     可以看出.NET中,集合类型分为泛型集合与非泛型集合。非泛型集合的类和接口位于System.Collections命名空间。泛型集合的类和接口位于System.Collections.Generic命名空间。

    ICollection接口是System.Collections命名空间中非泛型集合类的基接口,它继承自IEnumerable接口,从IEnumerable接口继承意味着实现该接口的实现类需要实现一个枚举器方法:GetEnumerator,该方法返回IEnumerator类型的数据。 

    IEnumerable<T>和IEnumerable是所有集合或集合接口的基接口,所有集合接口或集合都继承、实现了它。其中IEnumerable是最底层的接口。在非泛型集合里存放的都是System.Object类型。

    IEnumerator定义了遍历集合的基本方法,以便可以实现单向向前的访问集合中的每一个元素。而IEnumerable只有一个方法GetEnumerator即得到遍历器。

    public interface IEnumerator{
        bool MoveNext();
        object Current {  get; }
        void Reset();
    }
    

    分类:

    1.非关联性集合就是不用key操作的一些集合类,包含:

    List<T> 

    泛型的List 类提供了不限制长度的集合类型,List在内部维护了一定长度的数组(默认初始长度是4)。当插入元素的长度超过4或者初始长度 的时候,会去重新创建一个新的数组,这个新数组的长度是初始长度的2倍(不永远是2倍,当发现不断的要扩充的时候,倍数会变大),然后把原来的数组拷贝过来。所以如果知道将要用这个集合装多少个元素的话,可以在创建的时候指定初始值,这样就避免了重复的创建新数组和拷贝值

    LinkedList<T>

    LinkedList在内部维护了一个双向的链表,也就是说在LinkedList的任何位置添加或者删除数据其性能都是很快的。因为它不会导致其它元素的移动。如果对这个集合在中间的添加删除操作非常频繁的话,就建议使用LinkedList。 

    HashSet<T>

    HashSet是一个无序的能够保持唯一性的集合。HashSet非常适合在需要保持集合内元素唯一性但又不需要按顺序排列的时候。不支持下标访问

    SortedSet<T>

    SortedSet内部实现了一个二叉树,用来支持按顺序的排列元素。不支持下标访问

    Stack<T> 

    栈,先进后出的数据结构,不支持下标访问

    Queue<T>

    队列,先进先出的数据结构,不支持下标访问

    2.关联性集合类即我们常说的键值对集合,允许通过Key来访问和维护集合,包含:

    Dictionary<TKey,TValue>

    Dictionary<TKey,TValue>可能是最常用的关联性集合,它的访问,添加,删除数据所花费的时间是所有集合类里面最快的,因为它内部用了Hashtable作为存储结构,所以不管存储了多少键值对,查询/添加/删除所花费的时间都是一样的,它的时间复杂度是O(1)。

    Dictionary<TKey,TValue>优势是查找插入速度快,那么什么是它的劣势呢?因为采用Hashtable作为存储结构,就意味着里面的数据是无序排列的,所以想按一定的顺序去遍历Dictionary<TKey,TValue>里面的数据是要费一点工夫的。

    作为TKey的类型必须实现GetHashCode()和Equals() 或者提供一个IEqualityComparer,否则操作可能会出现问题。

    SortedDictionary<TKey,TValue>  

    SortedDictionary<TKey,TValue>和Dictionary<TKey,TValue>大致是类似的,但是在实现方式上有一点区别。

    SortedDictionary<TKey,TValue>用二叉树作为存储结构的。并且按key的顺序排列。因此,SortedDictionary<TKey,TValue>的TKey就必须要实现IComparable<TKey>。如果想要快速查询的同时又能很好的支持排序的话,就应该使用SortedDictionary。

    SortedList<TKey,TValue>

    SortedList<TKey,TValue>是另一个支持排序的关联性集合。不同的地方在于,SortedList实际是将数据存存储在数组中的。也就是说添加和移除操作都是线性的,时间复杂度是O(n),因为操作其中的元素可能导致所有的数据移动。但是因为在查找的时候利用了二分搜索,所以查找的性能会好一些,时间复杂度是O(log n)。所以推荐使用场景是这样地:如果想要快速查找,又想集合按照key的顺序排列,最后这个集合的操作(添加和移除)比较少的话,就应该使用Sorted

    具体的插入删除或者查找操作api等我就不一一写了,大家可以去搜一下,这里主要是区别一下这些集合

    展开全文
  • C#泛型集合揽胜转.pdf

    2020-03-24 16:17:14
    C#泛型集合揽胜 ( 转) 集合是 OOP中的一个重要概念 C#中对集合的全面支持更是该语言的精华之 一 为什么要用泛型集合 在 C# 2.0 之前主要可以通过两种方式实现集合 a. 使用 ArrayList 直接将对象放入 ArrayList 操作...
  • 在.NET FCL为我们提供了很多...结论:如果在C#2.0版本以上,尽量使用泛型集合类,而不使用非泛型集合类。因为,1. 泛型编程是从c#2.0开始才被.net支持的。2.泛型集合在性能和类型安全方面优于非泛型集 合。 。。。。
  • c#泛型集合

    2021-05-21 22:17:40
    泛型集合基本类型 常规操作 //泛型集合排序 List<int> intList = new List<int>() { 1,2,3,6,9,8}; foreach (int valu in intList) { label1.Text += string.Format("{0} \r\n", valu); } //升序...

    泛型集合基本类型 常规操作

    //泛型集合排序
    
     List<int> intList = new List<int>() { 1,2,3,6,9,8};
      foreach (int valu in intList)
      {
         label1.Text += string.Format("{0}  \r\n", valu);
     }
     //升序
       intList.Sort();
       label1.Text += "---------------------------\r\n";
       foreach (int valu in intList)
       {
           label1.Text += string.Format("{0}  \r\n", valu);
       }
    //降序
       intList.Reverse();
       label1.Text += "---------------------------\r\n";
       foreach (int valu in intList)
       {
           label1.Text += string.Format("{0}  \r\n", valu);
       }
       intList.Add(10);//添加
       intList.Count();//数量
       intList.Insert(0, 10);//插入
    

    泛型集合添加类参数

    List<Student> stuList1 = new List<Student>();
    stuList1.Add(objStudent);
    stuList1.Add(objStudent1);
    stuList1.Add(objStudent2);
     stuList.Insert(0,new Student()
                {
                    StudentId = 123,
                    StudentName = "汪超",
                }
                    );
    foreach (Student stu in stuList1)
    {
       label1.Text += string.Format("{0}  {1}\r\n",stu.StudentName, stu.StudentId);
    }
    stuList1.Sort();
    
    label1.Text += "---------------------------\r\n";
    foreach (Student stu in stuList1)
    {
    	label1.Text += string.Format("{0}  {1}\r\n", stu.StudentName, stu.StudentId);
     }
    stuList1.Sort(new StuIdASC());
    label1.Text += "------------学号升序---------------\r\n";
    foreach (Student stu in stuList1)
    {
     	label1.Text += string.Format("{0}  {1}\r\n", stu.StudentName, stu.StudentId);
    }
    stuList1.Sort(new StuIdDESC()); 
    
    label1.Text += "------------学号降序--------------\r\n";
    foreach (Student stu in stuList1)
    {
     	label1.Text += string.Format("{0}  {1}\r\n", stu.StudentName, stu.StudentId);
    }
    ## 字典
    ```csharp
    //字典 创建
    Dictionary<string, Student> stus = new Dictionary<string, Student>();
    //添加元素
    stus.Add("小王", objStudent);
    stus.Add("小王1", objStudent1);
    stus.Add("小王2", objStudent2);
    
    label1.Text = "";
    //取出元素
    // label1.Text = stus["小王"].StudentName;
    //遍历
    foreach (string key in stus.Keys)
    {
        label1.Text += "\r\n" + key;
    }
    label1.Text += string.Format("\r\n数量:{0}\r\n", stus.Count);
    label1.Text += "---------------------\r\n";
    foreach (Student valu in stus.Values)
    {
    	label1.Text += string.Format("\r\n{0}  {1}", valu.StudentName, valu.StudentId);
    }
    

        /// <summary>
        /// 学员
        /// </summary>
        class Student:IComparable <Student> //默认排序,只能有一种
        {
            //构造方法
            public Student()
            {
                studentId = 100;
                studentName = "汪超";
            }
            //字段
            private int studentId;
            private string studentName = string.Empty;
            //属性:
            public int StudentId
            {
                get { return studentId; }
                set { studentId = value; }
            }
            public string StudentName
            {
                get { return studentName; }
                set { studentName = value; }
            }
           //方法 :获取学员信息
            /// <summary>
            /// 
            /// </summary>
            /// <returns></returns>
             public string GetStudent()
            {
                string info = string.Format("姓名:{0} 学号:{1}", studentName, studentId);
                return info;
            }
            static public  int add(int a, int b)
            {
                return a+b;
            }
            /// <summary>
            /// 接口实现方法
            /// </summary>
            /// <param name="other"></param>
            /// <returns></returns>
            public int CompareTo(Student other)
            {
                // return other.studentId.CompareTo(this.studentId);
                //return this.studentId.CompareTo(other.studentId);
                return this.StudentName.CompareTo(other.StudentName);
            }
        }
    
    展开全文
  • 1、要使用Dictionary集合,需要导入C#泛型命名空间  System.Collections.Generic(程序集:mscorlib) 2、描述  1)、从一组键(Key)到一组值(Value)的映射,每一个添加项都是由一个值及其相关连的键组成  2)...
  • C#泛型集合定义及使用

    千次阅读 2019-10-17 12:17:19
    C#语言中泛型集合是泛型中最常见的应用,主要用于约束集合中存放的元素。 由于在集合中能存放任意类型的值,在取值时经常会遇到数据类型转换异常的情况,因此推荐在定义集合时使用泛型集合。 前面《C# ArrayList》...
  • 目录ArrayLIst非泛型集合List泛型集合List<>与ArrayList对比 ArrayLIst非泛型集合 1.使用非泛型集合之前需要注意调用System.Collections 2.非泛型集合在使用的时候对于集合中的元素没有明确的类型要求 3.非...
  • 建议20:使用泛型集合代替非泛型集合 在建议1中我们知道,如果要让代码高效运行,应该尽量避免装箱和拆箱,以及尽量减少转型。很遗憾,在微软提供给我们的第一代集合类型中没有做到这一点,下面我们看ArrayList这个...
  • 主要介绍了C#泛型集合Dictionary的使用方法,本文讲解了Dictionary的多种操作方法,需要的朋友可以参考下
  • C#泛型集合list的使用

    2019-11-14 22:26:59
    泛型集合List中只能有一个参数类型,“”中的T可以对集合中的元素类型进行约束。注意:泛型集合必须实例化,实例化时和普通类实例化时相同,必须在后面加上“()”。 以下就以几种用法来说明: 1.存储一种类型的数据....
  • C#泛型集合常用方法

    2020-02-25 14:58:56
    C#集合现在学了两个种了,但是学完以后发现它们除了在应用范围不一样之外,它们的方法基本上都是相同的,一开始看到那么多的方法是有点蒙的,但是细心看一看会发现一个规律。 1、Add():方法用于添加一个元素到...
  • 差集:先将两个集合重复的数据删除,再返回只在第一个集合中出现,在第二个集合中不出现的所有行,差集会自动去除重复元素,相当于返回 第一个集合的子集【元素不在第二个集合中】 此方法返回中 first 不显示的那些...
  • C#泛型集合Dictionary,V>的使用方法 1要使用Dictionary集合需要导入C#泛型命名空间 System.Collections.Generic程序集mscorlib 2描述 1从一组键Key到一组值Value的映射每一个添加项都是由一个值及其相关连的键组成 2...
  • 本篇文章主要是对C#读取数据库返回泛型集合(DataSetToList)进行了介绍,需要的朋友可以过来参考下,希望对大家有所帮助
  • C#泛型集合类(3)

    2017-05-29 00:27:14
    Dictionary ,TValue>:字典集合,存储一系列的键值对(KEY/VALUE),可以根据键而不是索引来获取值。 字典中插入键值对时,自动记录哪个键和哪个值关联。字典中不能包含重复的键,如果使用Add方法添加字典中已经存在...
  • 泛型集合 ArrayList 非泛型列表 HushTable 哈希表 Collections.Generic 泛型集合 List<T> 泛型列表 Dictionary<K,V> 字典 引入示例: Q:随机产生10个1~100范围内不重复奇数并存储 ...
  • C#泛型集合

    2021-09-19 11:00:45
    C#语言中泛型集合是泛型中最常见的应用,主要用于约束集合中存放的元素。 由于在集合中存放任意类型的值,在取值时经常会遇到数据类型装换异常的情况,因此推荐在定义集合适用反省集合。 泛型集合中主要使用List...
  • 今天,我遇到了一个问题,就是使用集合Dictionary的时候,总是要先判断是否存在Key值,然后再判断Key值对应的集合类是否有值,这样就很麻烦,比如这样: 既要判断Key值是否存在,又得判断这个Key值对应的集合是否有...
  • C# 语言和公共语言运行时 (CLR) 在 2.0 版本中添加了泛型泛型将类型参数的概念引入 .NET Framework,这样就可以设计具有相同特征的类和方法:在客户端代码声明并初始化这些类和方法之前,这些类和方法会延迟指定一...
  • C#泛型集合使用实例

    2009-07-24 23:11:10
    C#泛型集合使用实例C#泛型集合使用实例C#泛型集合使用实例
  • c# - 泛型集合

    2020-10-15 21:21:33
    创建泛型集合对象: 泛型集合类型一旦确定,那么里边的元素类型也随之确定(它与数组类似) static void Main(string[] args) { // 创建一个整数泛型集合 List<int> num = new List<int>(); } ...
  • C# 数组、集合与泛型集合的不同 三者区别: 数组(datatype[ ]):存储的类型单一,且不能动态增加。 集合(ArrayList):可以存储多种类型元素,还可以动态增加,但极大消耗资源。 泛型集合(List<T>):存储的...
  • C#集合与泛型集合

    2019-10-03 12:44:25
    看到这个标题,大家应该就知道有泛型集合,就有非泛型集合 ...C# 泛型集合之非泛型集合类与泛型集合类的对应: *****ArrayList对应List ***HashTable对应Dictionary *****Queue对应Queue **...
  • c# 泛型集合

    2019-10-05 15:53:32
    转载于:https://www.cnblogs.com/fanweisheng/p/11517704.html

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,230
精华内容 10,492
关键字:

c#泛型集合

友情链接: Ex12-stepMotor.rar