精华内容
下载资源
问答
  • 泛型最常见的用途是泛型集合,命名空间System.Collections.... 很多非泛型集合类都有对应的泛型集合类,下面是常用的非泛型集合类以及对应的泛型集合类: 非泛型集合类 泛型集合类 ArrayList List<...

    泛型最常见的用途是泛型集合,命名空间System.Collections.Generic 中包含了一些基于泛型的集合类,使用泛型集合类可以提供更高的类型安全性,还有更高的性能,避免了非泛型集合的重复的装箱和拆箱。
        很多非泛型集合类都有对应的泛型集合类,下面是常用的非泛型集合类以及对应的泛型集合类:

    非泛型集合类泛型集合类
    ArrayListList<T>
    HashTableDIctionary<T>
    QueueQueue<T>
    StackStack<T>
    SortedListSortedList<T>


        我们用的比较多的非泛型集合类主要有 ArrayList类 和 HashTable类。我们经常用HashTable 来存储将要写入到数据库或者返回的信息,在这之间要不断的进行类型的转化,增加了系统装箱和拆箱的负担,如果我们操纵的数据类型相对确定的化  用 Dictionary<TKey,TValue> 集合类来存储数据就方便多了,例如我们需要在电子商务网站中存储用户的购物车信息( 商品名,对应的商品个数)时,完全可以用 Dictionary<string, int> 来存储购物车信息,而不需要任何的类型转化。

        下面是简单的例子,包括声明,填充键值对,移除键值对,遍历键值对

        Dictionary<string, string> myDic = new Dictionary<string, string>();
        myDic.Add("aaa", "111");
        myDic.Add("bbb", "222");
        myDic.Add("ccc", "333");
        myDic.Add("ddd", "444");
        //如果添加已经存在的键,add方法会抛出异常
        try
        {
            myDic.Add("ddd","ddd");
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine("此键已经存在:" + ex.Message);
        }
        //解决add()异常的方法是用ContainsKey()方法来判断键是否存在
        if (!myDic.ContainsKey("ddd"))
        {
            myDic.Add("ddd", "ddd");
        }
        else
        {
            Console.WriteLine("此键已经存在:");
        
        }
        
        //而使用索引器来负值时,如果建已经存在,就会修改已有的键的键值,而不会抛出异常
        myDic ["ddd"]="ddd";
        myDic["eee"] = "555";
        
        //使用索引器来取值时,如果键不存在就会引发异常
        try
        {
            Console.WriteLine("不存在的键\"fff\"的键值为:" + myDic["fff"]);
        }
        catch (KeyNotFoundException ex)
        {
            Console.WriteLine("没有找到键引发异常:" + ex.Message);
        }
        //解决上面的异常的方法是使用ContarnsKey() 来判断时候存在键,如果经常要取健值得化最好用 TryGetValue方法来获取集合中的对应键值
        string value = "";
        if (myDic.TryGetValue("fff", out value))
        {
            Console.WriteLine("不存在的键\"fff\"的键值为:" + value );
        }
        else
        {     
            Console.WriteLine("没有找到对应键的键值"); 
        }
        
        //下面用foreach 来遍历键值对
        //泛型结构体 用来存储健值对
        foreach (KeyValuePair<string, string> kvp in myDic)
        {
            Console.WriteLine("key={0},value={1}", kvp.Key, kvp.Value);
        }
        //获取值得集合
        foreach (string s in myDic.Values)
        {
            Console.WriteLine("value={0}", s);
        }
        //获取值得另一种方式
        Dictionary<string, string>.ValueCollection values = myDic.Values;
        foreach (string s in values)
        {
            Console.WriteLine("value={0}", s);
        }


    常用的属性和方法如下:

     

     

    常用属性

    属性说明

     

    Comparer

    获取用于确定字典中的键是否相等的 IEqualityComparer

     

    Count

    获取包含在 Dictionary 中的键/值对的数目。

     

    Item

    获取或设置与指定的键相关联的值。

     

    Keys

    获取包含 Dictionary 中的键的集合。

     

    Values

    获取包含 Dictionary 中的值的集合。

     常用的方法方法说明

     

    Add

    将指定的键和值添加到字典中。

     

    Clear

    Dictionary 中移除所有的键和值。

     

    ContainsKey

    确定 Dictionary 是否包含指定的键。

     

    ContainsValue

    确定 Dictionary 是否包含特定值。

     

    Equals 

    已重载。 确定两个 Object 实例是否相等。 (从 Object 继承。)

     

    GetEnumerator

    返回循环访问 Dictionary 的枚举数。

     

    GetHashCode 

    用作特定类型的哈希函数。GetHashCode 适合在哈希算法和数据结构(如哈希表)中使用。 (从 Object 继承。)

     

    GetObjectData

    实现 System.Runtime.Serialization.ISerializable 接口,并返回序列化 Dictionary 实例所需的数据。

     

    GetType 

    获取当前实例的 Type。 (从 Object 继承。)

     

    OnDeserialization

    实现 System.Runtime.Serialization.ISerializable 接口,并在完成反序列化之后引发反序列化事件。

     

    ReferenceEquals 

    确定指定的 Object 实例是否是相同的实例。 (从 Object 继承。)

     

    Remove

    Dictionary 中移除所指定的键的值。

     

    ToString 

    返回表示当前 ObjectString。 (从 Object 继承。)

     

    TryGetValue

    获取与指定的键相关联的值。

    转载于:https://www.cnblogs.com/justForMe/archive/2012/02/22/2363127.html

    展开全文
  • 泛型和泛型集合类用法泛型和泛型集合类用法泛型和泛型集合类用法泛型和泛型集合类用法泛型和泛型集合类用法
  • 下面是常用的非泛型集合类以及对应的泛型集合类泛型集合类 泛型集合类 ArrayList List HashTable DIctionary Queue Queue Stack Stack SortedList SortedList   ...
      
    

    下面是常用的非泛型集合类以及对应的泛型集合类

    非泛型集合类泛型集合类
    ArrayListList<T>
    HashTableDIctionary<T>
    QueueQueue<T>
    StackStack<T>
    SortedListSortedList<T>

     

    arraylist和list<>对比  http://blog.csdn.net/guoyz_1/archive/2009/02/25/3934611.aspx

     

     

    实用的泛型 文章

    http://www.diybl.com/course/4_webprogram/asp.net/asp_netshl/2008320/105880.html

     

    泛型最常见的用途是泛型集合,命名空间System.Collections.Generic 中包含了一些基于泛型的集合类,使用泛型集合类可以提供更高的类型安全性,还有更高的性能,避免了非泛型集合的重复的装箱和拆箱。
        很多非泛型集合类都有对应的泛型集合类,下面是常用的非泛型集合类以及对应的泛型集合类:

    非泛型集合类泛型集合类
    ArrayListList
    HashTableDIctionary
    QueueQueue
    StackStack
    SortedListSortedList

     

     

    1、list<>

    myList.Capacity       //容量
    myList.Count //元素数目
    myList.Insert(2,"new item") //插入新元素
    myList.Add("new item") //追加元素
    mylist.Sort(); //排序
    mylist.Reverse(); //反向排序
    myList.Remove("new item") //移除指定元素
    myList.TrimExcess() //收缩容量。使得Capacity = Count
    myList.Contains("new items") //查询是否名含指定内容
    myList.Clear() //清除

    IList<string> newList = myList.AsReadOnly() //创建myList的一个只读版本
    当myList有更改以后newList也跟着变动(指针?)

    string[] myCollection = {"one","tow","three","four"}; //定义数组
    List<string> mylist = new List<string>(myCollection);
    mylist.AddRange(mylist) //自加
    mylist.RemoveRange(2,2); //移除
    string[] newCollecton = {"one","tow","three","four"};
    mylist.InsertRange(3,newCollection) //插入

     


        我们用的比较多的非泛型集合类主要有 ArrayList类 和 HashTable类。我们经常用HashTable 来存储将要写入到数据库或者返回的信息,在这之间要不断的进行类型的转化,增加了系统装箱和拆箱的负担,如果我们操纵的数据类型相对确定的化  用 Dictionary 集合类来存储数据就方便多了,例如我们需要在电子商务网站中存储用户的购物车信息( 商品名,对应的商品个数)时,完全可以用 Dictionary 来存储购物车信息,而不需要任何的类型转化。

        下面是简单的例子,包括声明,填充键值对,移除键值对,遍历键值对

        Dictionary<string, string> myDic = new Dictionary<string, string>();
        myDic.Add("aaa", "111");
        myDic.Add("bbb", "222");
        myDic.Add("ccc", "333");
        myDic.Add("ddd", "444");
        //如果添加已经存在的键,add方法会抛出异常
        try
        {
            myDic.Add("ddd","ddd");
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine("此键已经存在:" + ex.Message);
        }
        //解决add()异常的方法是用ContainsKey()方法来判断键是否存在
        if (!myDic.ContainsKey("ddd"))
        {
            myDic.Add("ddd", "ddd");
        }
        else
        {
            Console.WriteLine("此键已经存在:");
        
        }
        
        //而使用索引器来负值时,如果建已经存在,就会修改已有的键的键值,而不会抛出异常
        myDic ["ddd"]="ddd";
        myDic["eee"] = "555";
        
        //使用索引器来取值时,如果键不存在就会引发异常
        try
        {
            Console.WriteLine("不存在的键/"fff/"的键值为:" + myDic["fff"]);
        }
        catch (KeyNotFoundException ex)
        {
            Console.WriteLine("没有找到键引发异常:" + ex.Message);
        }
        //解决上面的异常的方法是使用ContarnsKey() 来判断时候存在键,如果经常要取健值得化最好用 TryGetValue方法来获取集合中的对应键值
        string value = "";
        if (myDic.TryGetValue("fff", out value))
    {
            Console.WriteLine("不存在的键/"fff/"的键值为:" + value );
        }
        else
        {     
            Console.WriteLine("没有找到对应键的键值"); 
        }
        
        //下面用foreach 来遍历键值对
        //泛型结构体 用来存储健值对
        foreach (KeyValuePair<string, string> kvp in myDic)
        {
            Console.WriteLine("key={0},value={1}", kvp.Key, kvp.Value);
        }
        //获取值得集合
        foreach (string s in myDic.Values)
        {
            Console.WriteLine("value={0}", s);
        }
        //获取值得另一种方式
        Dictionary<string, string>.ValueCollection values = myDic.Values;
        foreach (string s in values)
        {
            Console.WriteLine("value={0}", s);
        }


    常用的属性和方法如下:

     

     

    常用属性

    属性说明

     

    Comparer

    获取用于确定字典中的键是否相等的 IEqualityComparer

     

    Count

    获取包含在 Dictionary 中的键/值对的数目。

     

    Item

    获取或设置与指定的键相关联的值。

     

    Keys

    获取包含 Dictionary 中的键的集合。

     

    Values

    获取包含 Dictionary 中的值的集合。

     常用的方法方法说明

     

    Add

    将指定的键和值添加到字典中。

     

    Clear

    Dictionary 中移除所有的键和值。

     

    ContainsKey

    确定 Dictionary 是否包含指定的键。

     

    ContainsValue

    确定 Dictionary 是否包含特定值。

     

    Equals 

    已重载。 确定两个 Object 实例是否相等。 (从 Object 继承。)

     

    GetEnumerator

    返回循环访问 Dictionary 的枚举数。

     

    GetHashCode 

    用作特定类型的哈希函数。GetHashCode 适合在哈希算法和数据结构(如哈希表)中使用。 (从 Object 继承。)

     

    GetObjectData

    实现 System.Runtime.Serialization.ISerializable 接口,并返回序列化 Dictionary 实例所需的数据。

     

    GetType 

    获取当前实例的 Type。 (从 Object 继承。)

     

    OnDeserialization

    实现 System.Runtime.Serialization.ISerializable 接口,并在完成反序列化之后引发反序列化事件。

     

    ReferenceEquals 

    确定指定的 Object 实例是否是相同的实例。 (从 Object 继承。)

     

    Remove

    Dictionary 中移除所指定的键的值。

     

    ToString 

    返回表示当前 Object String。 (从 Object 继承。)

     

    TryGetValue

    获取与指定的键相关联的值。

    展开全文
  • C#非泛型集合类泛型集合类的区别

    千次阅读 2012-06-01 16:15:43
    C# 泛型集合之非泛型集合类泛型集合类的对应: ArrayList对应List HashTable对应Dictionary Queue对应Queue Stack对应Stack SortedList对应SortedList   C# 集合类 Array Arraylist List Hashtable ...

    C# 泛型集合之非泛型集合类与泛型集合类的对应:

    ArrayList对应List

    HashTable对应Dictionary

    Queue对应Queue

    Stack对应Stack

    SortedList对应SortedList

     

    C# 集合类 Array Arraylist List Hashtable Dictionary Stack Queue
    1.数组是固定大小的,不能伸缩。虽然System.Array.Resize这个泛型方法可以重置数组大小,
    但是该方法是重新创建新设置大小的数组,用的是旧数组的元素初始化。随后以前的数组就废弃!而集合却是可变长的
    2.数组要声明元素的类型,集合类的元素类型却是object.
    3.数组可读可写不能声明只读数组。集合类可以提供ReadOnly方法以只读方式使用集合。
    4.数组要有整数下标才能访问特定的元素,然而很多时候这样的下标并不是很有用。集合也是数据列表却不使用下标访问。
    很多时候集合有定制的下标类型,对于队列和栈根本就不支持下标访问! 
     

    ArrayList 是数组的复杂版本。ArrayList 类提供在大多数 Collections 类中提供但不在 Array 类中提供的一些功能。例如:

    Array 的容量是固定的,而 ArrayList 的容量是根据需要自动扩展的。如果更改了 ArrayList.Capacity 属性的值,则自动进行内存重新分配和元素复制。
    ArrayList 提供添加、插入或移除某一范围元素的方法。在 Array 中,您只能一次获取或设置一个元素的值。
    使用 Synchronized 方法可以很容易地创建 ArrayList 的同步版本。而 Array 将一直保持它直到用户实现同步为止。
    ArrayList 提供将只读和固定大小包装返回到集合的方法。而 Array 不提供。
    另一方面,Array 提供 ArrayList 所不具有的某些灵活性。例如:

    可以设置 Array 的下限,但 ArrayList 的下限始终为零。
    Array 可以具有多个维度,而 ArrayList 始终只是一维的。
    特定类型(不包括 Object)的 Array 的性能比 ArrayList 好,这是因为 ArrayList 的元素属于 Object 类型,所以在存储或检索值类型时通常发生装箱和取消装箱。
    要求一个数组的大多数情况也可以代之以使用 ArrayList。它更易于使用,并且通常具有与 Object 类型的数组类似的性能。

    Array 位于 System 命名空间中;ArrayList 位于 System.Collections 命名空间中。

     

     



    //数组
    int[] intArray1;
    //初始化已声明的一维数组
    intArray1 = new int[3];
    intArray1 = new int[3]{1,2,3};
    intArray1 = new int[]{1,2,3};



    //ArrayList类对象被设计成为一个动态数组类型,其容量会随着需要而适当的扩充
    方法
    1:Add()向数组中添加一个元素,
    2:Remove()删除数组中的一个元素
    3:RemoveAt(int i)删除数组中索引值为i的元素
    4:Reverse()反转数组的元素
    5:Sort()以从小到大的顺序排列数组的元素
    6:Clone()复制一个数组


     

     //ArrayList动态数组 定义 赋值 输出  ArrayList可以不用指定维数 可动态赋值  赋不同类型值
                ArrayList arrayList1 = new ArrayList();
                arrayList1.
                arrayList1.Add("a");
                arrayList1.Add(1);
                arrayList1.Add("b");
                Response.Write(arrayList1[1]);

     

     

       //Array数组类 所有数组的基类 定义 赋值 输出  Array的容量是固定的 先指定大小 在赋值
                Array arrayList2 = Array.CreateInstance(typeof(string), 6);
                arrayList2.SetValue("a", 0);
                arrayList2.SetValue("b", 1);
                Response.Write(arrayList2.GetValue(1));

     

     

       //数组 定义 赋值 输出  先指定大小 在赋值
                string[] arrayList;
                arrayList=new string[]{"A","B","C","D"};
                arrayList[0] = "abcde";
                arrayList[2] = "1234";

                arrayList.SetValue("dd", 3);
                Response.Write(arrayList[0]);

     
       //哈希表
                Hashtable abc = new Hashtable();
                abc.Add("1", "34");
                if (abc.Contains("1"))
                {
                    Response.Write(abc["1"]);
                }

     

      //声明一个二维数组

               int[,] cells=int[3,3];

     

     

     

     //初始化一个二维整数数组

              int[,] cells={{1,0,2},{1,2,0},{1,2,1}};




    //List
    可通过索引访问的对象的强类型列表。提供用于对列表进行搜索、排序和操作的方法
    在决定使用 List 还是使用 ArrayList 类(两者具有类似的功能)时,记住 List 类在大多数情况下执行得更好并且是类型安全的。如果对 List 类的类型 T 使用引用类型,则

    两个类的行为是完全相同的。但是,如果对类型 T 使用值类型,则需要考虑实现和装箱问题。

    如果对类型 T 使用值类型,则编译器将特别针对该值类型生成 List 类的实现。这意味着不必对 List 对象的列表元素进行装箱就可以使用该元素,并且在创建大约 500 个列表

    元素之后,不对列表元素装箱所节省的内存将大于生成该类实现所使用的内存。



    //Dictionary
    表示键和值的集合。Dictionary遍历输出的顺序,就是加入的顺序,这点与Hashtable不同



    //SortedList类
    与哈希表类似,区别在于SortedList中的Key数组排好序的

    //Hashtable类
    哈希表,名-值对。类似于字典(比数组更强大)。哈希表是经过优化的,访问下标的对象先散列过。如果以任意类型键值访问其中元素会快于其他集合。
    GetHashCode()方法返回一个int型数据,使用这个键的值生成该int型数据。哈希表获取这个值最后返回一个索引,表示带有给定散列的数据项在字典中存储的位置。


    //Stack类
    栈,后进先出。push方法入栈,pop方法出栈。



    Queue类
    队列,先进先出。enqueue方法入队列,dequeue方法出队列。


    -------------------------------------------------------------

    //Dictionary
    System.Collections.DictionaryEntry dic=new System.Collections.DictionaryEntry("key1","value1");

    Dictionary<int, string> fruit = new Dictionary<int, string>();

    //加入重复键会引发异常
    fruit.Add(1, "苹果");
    fruit.Add(2, "桔子");
    fruit.Add(3, "香蕉");
    fruit.Add(4, "菠萝");

    //因为引入了泛型,所以键取出后不需要进行Object到int的转换,值的集合也一样
    foreach (int i in fruit.Keys)
    {
    Console.WriteLine("键是:{0} 值是:{1}",i,fruit);
    }
    //删除指定键,值
    fruit.Remove(1);
    //判断是否包含指定键
    if (fruit.ContainsKey(1))
    {
    Console.WriteLine("包含此键");
    }
    //清除集合中所有对象
    fruit.Clear();
    }


    //ArrayList
    System.Collections.ArrayList list=new System.Collections.ArrayList();
    list.Add(1);
    list.Add(2);
    for(int i=0;i<list.Count;i++)
    {
    System.Console.WriteLine(list[i]);
    }




    //List
    //声明一个List对象,只加入string参数
    List<string> names = new List<string>();
    names.Add("乔峰");
    names.Add("欧阳峰");
    names.Add("马蜂");
    //遍历List
    foreach (string name in names)
    {
    Console.WriteLine(name);
    }
    //向List中插入元素
    names.Insert(2, "张三峰");
    //移除指定元素
    names.Remove("马蜂");




    //HashTable
    System.Collections.Hashtable table=new System.Collections.Hashtable();
    table.Add("table1",1);
    table.Add("table2",2);
    System.Collections.IDictionaryEnumerator d=table.GetEnumerator();
    while(d.MoveNext())
    {
    System.Console.WriteLine(d.Entry.Key);
    }



    //Queue
    System.Collections.Queue queue=new System.Collections.Queue();
    queue.Enqueue(1);
    queue.Enqueue(2);

    System.Console.WriteLine(queue.Peek());
    while(queue.Count>0)
    {
    System.Console.WriteLine(queue.Dequeue());
    }


    //SortedList
    System.Collections.SortedList list=new System.Collections.SortedList();
    list.Add("key2",2);
    list.Add("key1",1);
    for(int i=0;i<list.Count;i++)
    {
    System.Console.WriteLine(list.GetKey(i));
    }


    //Stack
    System.Collections.Stack stack=new System.Collections.Stack();
    stack.Push(1);
    stack.Push(2);

    System.Console.WriteLine(stack.Peek());
    while(stack.Count>0)
    {
    System.Console.WriteLine(stack.Pop());
    }

     

    展开全文
  • 集合类的使用大体追寻如下次序:优先选用现有的泛型集合类、接着才是选择制定自己特有的泛型集合类、然后选择使用现有非泛型集合类、最后选择自己定义需要的非泛型集合类。   集合类具有以下特点:...

    集合类的使用大体追寻如下次序:优先选用现有的泛型集合类、接着才是选择制定自己特有的泛型集合类、然后选择使用现有非泛型集合类、最后选择自己定义需要的非泛型集合类。

     

    集合类具有以下特点:

    • 集合类定义为 System.Collections 或 System.Collections.Generic 命名空间的一部分。

    • 大多数集合类都派生自 ICollectionIComparerIEnumerableIListIDictionaryIDictionaryEnumerator 接口以及它们的等效泛型接口。

    • 使用泛型集合类可以提供更高的类型安全性,在某些情况下还可以提供更好的性能,尤其是在存储值类型时,这些优势会体现得更明显。

     

    下面的泛型类型对应于现有的非泛型集合类型:

    • List< (Of < ( T> ) > ) 是对应于 ArrayList 的泛型类。

    • Dictionary< (Of < ( TKey, TValue> ) > ) 是对应于 Hashtable 的泛型类。

    • Collection< (Of < ( T> ) > ) 是对应于 CollectionBase 的泛型类。Collection< (Of < ( T> ) > ) 可以用作基类,但与 CollectionBase 不同的是它不是抽象的。这样使用起来要方便得多。

    • ReadOnlyCollection< (Of < ( T> ) > ) 是对应于 ReadOnlyCollectionBase 的泛型类。ReadOnlyCollection< (Of < ( T> ) > ) 不是抽象的,它具有一个构造函数,该构造函数使其易于将现有的 List< (Of < ( T> ) > ) 公开为只读集合。

    • Queue< (Of < ( T> ) > ) 、Stack< (Of < ( T> ) > ) 和 SortedList< (Of < ( TKey, TValue> ) > ) 泛型类分别对应于与其同名的非泛型类。

    有几种泛型集合类型没有对应的非泛型类型:

    • LinkedList< (Of < ( T> ) > ) 是一个通用链接列表,它提供运算复杂度为 O(1) 的插入和移除操作。

    • SortedDictionary< (Of < ( TKey, TValue> ) > ) 是一个排序的字典,其插入和检索操作的运算复杂度为 O(log n ),这使得它成为 SortedList< (Of < ( TKey, TValue> ) > ) 的十分有用的替代类型。

    • KeyedCollection< (Of < ( TKey, TItem> ) > ) 是介于列表和字典之间的混合类型,它提供了一种存储包含自己键的对象的方法。

    LINQ to Objects

    LINQ to Objects 功能允许使用 LINQ 查询访问内存中的对象,但条件是该对象类型要实现 IEnumerable 或 IEnumerable< (Of < ( T> ) > ) 。LINQ 查询提供了一种通用的数据访问模式;与标准 foreach 循环相比,它通常更加简洁,可读性更高;这种查询可提供筛选、排序和分组功能。LINQ 查询还可提高性能。有关更多信息,请参见 LINQ to Objects 。

    其他功能

    一些泛型类型具有非泛型集合类型中没有的功能。例如,List< (Of < ( T> ) > ) 类(对应于非泛型 ArrayList 类)具有许多接受泛型委托(如允许指定搜索列表的方法的 Predicate< (Of < ( T> ) > ) 委托、表示操作每个列表元素的 Action< (Of < ( T> ) > ) 委托和允许定义类型之间转换的 Converter< (Of < ( TInput, TOutput> ) > ) 委托)的方法。

    List< (Of < ( T> ) > ) 类允许指定您自己的用于排序和搜索列表的 IComparer< (Of < ( T> ) > ) 泛型接口实现。SortedDictionary< (Of < ( TKey, TValue> ) > ) 和 SortedList< (Of < ( TKey, TValue> ) > ) 类也具有此功能,此外还允许在创建集合时指定比较器。类似地,Dictionary< (Of < ( TKey, TValue> ) > ) 和 KeyedCollection< (Of < ( TKey, TItem> ) > ) 类允许您指定自己的相等比较器。

    展开全文
  • 今天有空正好把泛型和非泛型集合类写了一个比较,并做了个的例程,可以比较清楚的理解它们概念和使用方法。 泛型与非泛型集合类在C#程序中是非常重要的一个基础概念,这里列一个表来进行对比:   非泛型集合...
  • 在C#语言编程过程中,List集合类是最常见的泛型集合类,其实除了List集合,还有其他一些常用的泛型集合类,如字典类型Dictionary泛型集合类、先进先出的队列类型Queue泛型集合类、后进先出的栈Stack泛型集合类、链表...
  • java 泛型集合类

    2017-03-06 21:39:31
    使用泛型集合,可将一个集合中的元素限定为一个特定类型,集合中只能存储同一个类型的对象,这样更安全。且当取出一个对象时,不需要对对象进行强制类型转换。 HashMap,Integer> maps = new HashMap, Integer>(); ...
  • 里面有本人学习做的笔记,有常用的api,特别容易理解
  • 泛型将类型参数的概念引入 .NET Framework,这样就可以设计具有相同特征的和方法:在客户端代码声明并初始化这些和方法之前,这些和方法会延迟指定一个或多个类型(使用占位符~3:数字代表类型参数个数)。
  • 今天有空正好把泛型和非泛型集合类写了一个比较,并做了个的例程,可以比较清楚的理解它们概念和使用方法。 泛型与非泛型集合类在C#程序中是非常重要的一个基础概念,这里列一个表来进行对比:   ...
  • 泛型与非泛型集合类的区别及使用例程,包括ArrayList,Hashtable,List,Dictionary,SortedList,Queue,Stack等
  • 主要用于数据前台展示,所以为了方便,都转成了string类型... /// 将泛型集合类转换成DataTable,返回的DataTable所有列的数据类型为string型,且列顺序与字符串提供的字段顺序一致 /// /// 集合项类型 /// 集合 ///
  • Jdk1.5中支持了泛型,在泛型的使用过程中经常会遇到这样一问题 Parent public class Parent { // your code } //Child public class Child extends Parent { // your code } ...
  • 在.NET FCL为我们提供了很多...结论:如果在C#2.0版本以上,尽量使用泛型集合类,而不使用非泛型集合类。因为,1. 泛型编程是从c#2.0开始才被.net支持的。2.泛型集合在性能和类型安全方面优于非泛型集 合。 。。。。
  • JAVA泛型集合

    2018-04-26 14:01:18
    java 泛型 集合类java 泛型 集合类java 泛型 集合类java 泛型 集合类
  • 泛型集合和ArrayList的装箱拆箱、常见的泛型类型、泛型和泛型方法、泛型约束、 泛型委托泛型很难理解?不然在接触的一个新的概念的时候,总会感觉难以理解,当你掌握并能熟练地使用的时候,发现这个概念其实简单...
  • 泛型最常见的用途是泛型集合,命名空间System.Collections.Generic 中包含了一些基于泛型的集合类,使用泛型集合类可以... 很多非泛型集合类都有对应的泛型集合类,下面是常用的非泛型集合类以及对应的泛型集合类
  • 泛型最常见的用途是泛型集合,命名空间System.Collections.Generic 中包含了一些基于泛型的集合类,使用泛型... 很多非泛型集合类都有对应的泛型集合类,下面是常用的非泛型集合类以及对应的泛型集合类: 非泛型集合类
  • 泛型最常见的用途是泛型集合,命名空间System.Collections.Generic 中包含了一些基于... 很多非泛型集合类都有对应的泛型集合类,下面是常用的非泛型集合类以及对应的泛型集合类:非泛型集合类泛型集合类ArrayListList
  • 泛型最常见的用途是泛型集合,命名空间System.Collections.Generic 中包含了一些基于泛型的集合类,使用泛型... 很多非泛型集合类都有对应的泛型集合类,下面是常用的非泛型集合类以及对应的泛型集合类: 非泛型集合类
  • 泛型集合使用基础

    2015-11-12 17:08:30
    泛型最常见的用途是泛型集合,命名空间System.Collections...很多非泛型集合类都有对应的泛型集合类,下面是常用的非泛型集合类以及对应的泛型集合类: 非泛型集合类 泛型集合类  ArrayList List  HashTable DIcti

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 129,738
精华内容 51,895
关键字:

泛型集合类