精华内容
下载资源
问答
  • C# 集合类 Array Arraylist List Hashtable Dictionary Stack Queue

    (1)数组

    1.数组是固定大小的,不能伸缩。

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


    数组:固定长度的一段内存。
    ArrayList:可以理解为可以动态增加内存的数组,是一种链表。
    list是一种范型链表,解决了ArrayList对于值类型需要装箱拆箱的缺点。
     

    [] 是针对特定类型固定长度的。

    Array 是针对任意类型固定长度的。

    List 是针对特定类型任意长度的。

    ArrayList 是针对任意类型任意长度的。


    //数组


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

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

    //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方法出队列。 

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

    1. //Dictionary 
    2. System.Collections.DictionaryEntry dic=new System.Collections.DictionaryEntry("key1","value1"); 
    3. Dictionary<intstring> fruit = new Dictionary<intstring>(); 
    4. //加入重复键会引发异常 
    5. fruit.Add(1, "苹果"); 
    6. fruit.Add(2, "桔子"); 
    7. fruit.Add(3, "香蕉"); 
    8. fruit.Add(4, "菠萝"); 
    9. //因为引入了泛型,所以键取出后不需要进行Object到int的转换,值的集合也一样 
    10. foreach (int i in fruit.Keys) 
    11. Console.WriteLine("键是:{0} 值是:{1}",i,fruit); 
    12. //删除指定键,值 
    13. fruit.Remove(1); 
    14. //判断是否包含指定键 
    15. if (fruit.ContainsKey(1)) 
    16. Console.WriteLine("包含此键"); 
    17. //清除集合中所有对象 
    18. 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()); 
    }



    Hashtable 和 Dictionary <K, V> 类型
    1:单线程程序中推荐使用 Dictionary, 有泛型优势, 且读取速度较快, 容量利用更充分.
    2:多线程程序中推荐使用 Hashtable, 默认的 Hashtable 允许单线程写入, 多线程读取, 对 Hashtable 进一步调用 Synchronized() 方法可以获得完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用 lock 语句进行保护, 效率大减.
    3:Dictionary 有按插入顺序排列数据的特性 (注: 但当调用 Remove() 删除过节点后顺序被打乱), 因此在需要体现顺序的情境中使用 Dictionary 能获得一定方便.

    HashTable中的key/value均为object类型,由包含集合元素的存储桶组成。存储桶是 HashTable中各元素的虚拟子组,与大多数集合中进行的搜索和检索相比,存储桶可令搜索和检索更为便捷。每一存储桶都与一个哈希代码关联,该哈希代码是使用哈希函数生成的并基于该元素的键。HashTable的优点就在于其索引的方式,速度非常快。如果以任意类型键值访问其中元素会快于其他集合,特别是当数据量特别大的时候,效率差别尤其大。

    HashTable的应用场合有:做对象缓存,树递归算法的替代,和各种需提升效率的场合

    Dictionary和HashTable内部实现差不多,但前者无需装箱拆箱操作,效率略高一点。

     

    HashTable是经过优化的,访问下标的对象先散列过,所以内部是无序散列的,保证了高效率,也就是说,其输出不是按照开始加入的顺序,而 Dictionary遍历输出的顺序,就是加入的顺序,这点与Hashtable不同。如果一定要排序HashTable输出,只能自己实现:

     

    HashTable与线程安全:

    为了保证在多线程的情况下的线程同步访问安全,微软提供了自动线程同步的HashTable:

    如果 HashTable要允许并发读但只能一个线程写, 要这么创建 HashTable实例:

        //Thread safe HashTable
        System.Collections.Hashtable htSyn = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());

    这样, 如果有多个线程并发的企图写HashTable里面的 item, 则同一时刻只能有一个线程写, 其余阻塞; 对读的线程则不受影响。

     

    另外一种方法就是使用lock语句,但要lock的不是HashTable,而是其SyncRoot;虽然不推荐这种方法,但效果一样的,因为源代码就是这样实现的:

    //Thread safe

    private static System.Collections.Hashtable htCache = new System.Collections.Hashtable ();

     

    public static void AccessCache ()

    {

        lock ( htCache.SyncRoot )

        {

            htCache.Add ( "key", "value" );

     

            //Be careful: don't use foreach to operation on the whole collection

            //Otherwise the collection won't be locked correctly even though indicated locked

            //--by MSDN

        }

    }

     

     

    //Is equivalent to 等同于 (lock is equivalent to Monitor.Enter and Exit()

    public static void AccessCache ()

    {

        System.Threading.Monitor.Enter ( htCache.SyncRoot );

     

        try

        {

            /* critical section */

            htCache.Add ( "key", "value" );

     

            //Be careful: don't use foreach to operation on the whole collection

            //Otherwise the collection won't be locked correctly even though indicated locked

            //--by MSDN

        }

        finally

        {

            System.Threading.Monitor.Exit ( htCache.SyncRoot );

        }

    }

     

    List和Map都是接口不能实例化的
    以前这么写List list = new Vector();
    现在这么写List list = new ArrayList();
    用ArrayList 代替了Vector 因为前者的性能比后者好;
    但是两个都是实现了List借口的
    同理Map map = new HashTable();(以前)
    Map map = new HashMap();(现在)

    (二)

    ArrayList和HashMap是异步的,Vector和HashTable是同步的,所以Vector和HashTable是线程安全的,而 ArrayList和HashMap并不是线程安全的。因为同步需要花费机器时间,所以Vector和HashTable的执行效率要低于 ArrayList和HashMap。
    Collection
    ├List
    │├LinkedList
    │├ArrayList
    │└Vector
    │ └Stack
    └Set
    Map
    ├Hashtable
    ├HashMap
    └WeakHashMap

    List接口
    List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。
    和下面要提到的Set不同,List允许有相同的元素。
    除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个 ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素,还能向前或向后遍历。
    实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。
    ArrayList类
    ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。
    size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
    每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
    和LinkedList一样,ArrayList也是非同步的(unsynchronized)。
    Map接口
    请注意,Map没有继承Collection接口,Map提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个 value。Map接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。
    HashMap类
    HashMap和Hashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null value和null key。,但是将HashMap视为Collection时(values()方法可返回Collection),其迭代子操作时间开销和HashMap 的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将HashMap的初始化容量设得过高,或者load factor过低。

    (三)

    1. List是接口,List特性就是有序,会确保以一定的顺序保存元素.
    ArrayList是它的实现类,是一个用数组实现的List.
    Map是接口,Map特性就是根据一个对象查找对象.
    HashMap是它的实现类,HashMap用hash表实现的Map,就是利用对象的hashcode(hashcode()是Object的方法)进行快速散列查找.(关于散列查找,可以参看<<数据结构>>)
    2. 一般情况下,如果没有必要,推荐代码只同List,Map接口打交道.
    比如:List list = new ArrayList();
    这样做的原因是list就相当于是一个泛型的实现,如果想改变list的类型,只需要:
    List list = new LinkedList();//LinkedList也是List的实现类,也是ArrayList的兄弟类
    这样,就不需要修改其它代码,这就是接口编程的优雅之处.
    另外的例子就是,在类的方法中,如下声明:
    private void doMyAction(List list){}
    这样这个方法能处理所有实现了List接口的类,一定程度上实现了泛型函数.
    3. 如果开发的时候觉得ArrayList,HashMap的性能不能满足你的需要,可以通过实现List,Map(或者Collection)来定制你的自定义类.

    HashTable中的 key/value均为object类型,由包含集合元素的存储桶组成。存储桶是 HashTable中各元素的虚拟子组,与大多数集合中进行的搜索和检索相比,存储桶可令搜索和检索更为便捷。每一存储桶都与一个哈希代码关联,该哈希代码是使用哈希函数生成的并基于该元素的键。HashTable的优点就在于其索引的方式,速度非常快。如果以任意类型键值访问其中元素会快于其他集合,特别是当数据量特别大的时候,效率差别尤其大。

    HashTable的应用场合有:做对象缓存,树递归算法的替代,和各种需提升效率的场合。

    //Hashtable sample
    System.Collections.Hashtable ht = new System.Collections.Hashtable();

    //--Be careful: Keys can't be duplicated, and can't be null----
    ht.Add(1, "apple");
    ht.Add(2, "banana");
    ht.Add(3, "orange");

    //Modify item value:
    if(ht.ContainsKey(1))
    ht[1] = "appleBad";

    //The following code will return null oValue, no exception
    object Value = ht[5];

    //traversal 1:
    foreach (DictionaryEntry de in ht)
    {
    Console.WriteLine(de.Key);
    Console.WriteLine(de.Value);
    }

    //traversal 2:
    System.Collections.IDictionaryEnumerator d = ht.GetEnumerator();
    while (d.MoveNext())
    {
    Console.WriteLine("key:{0} value:{1}", d.Entry.Key, d.Entry.Value);
    }

    //Clear items
    ht.Clear();

    Dictionary和HashTable内部实现差不多,但前者无需装箱拆箱操作,效率略高一点。


    //Dictionary sample
    System.Collections.Generic.Dictionary<int, string> fruits =
    new System.Collections.Generic.Dictionary<int, string>();

    fruits.Add(1, "apple");
    fruits.Add(2, "banana");
    fruits.Add(3, "orange");

    foreach (int i in fruits.Keys)
    {
    Console.WriteLine("key:{0} value:{1}", i, fruits);
    }

    if (fruits.ContainsKey(1))
    {
    Console.WriteLine("contain this key.");
    }


    ArrayList是一维变长数组,内部值为object类型,效率一般:




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


    HashTable 是经过优化的,访问下标的对象先散列过,所以内部是无序散列的,保证了高效率,也就是说,其输出不是按照开始加入的顺序,而Dictionary遍历输出的顺序,就是加入的顺序,这点与Hashtable不同。如果一定要排序HashTable输出,只能自己实现:



    //Hashtable sorting
    System.Collections.ArrayList akeys = new System.Collections.ArrayList(ht.Keys); //from Hashtable
    akeys.Sort(); //Sort by leading letter
    foreach (string skey in akeys)
    {
    Console.Write(skey + ":");
    Console.WriteLine(ht[skey]);
    }


    HashTable与线程安全:

    为了保证在多线程的情况下的线程同步访问安全,微软提供了自动线程同步的HashTable:


    如果 HashTable要允许并发读但只能一个线程写, 要这么创建 HashTable实例:


    //Thread safe HashTable
    System.Collections.Hashtable htSyn = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
    这样, 如果有多个线程并发的企图写HashTable里面的 item, 则同一时刻只能有一个线程写, 其余阻塞; 对读的线程则不受影响。



    另外一种方法就是使用lock语句,但要lock的不是HashTable,而是其SyncRoot;虽然不推荐这种方法,但效果一样的,因为源代码就是这样实现的:



    //Thread safe
    private static Hashtable htCache = new Hashtable();

    public static void AccessCache()
    {
    lock (htCache.SyncRoot)
    {
    //Do something
    }
    }
    System.Collections 命名空间包含接口和类,这些接口和类定义各种对象(如列表、队列、位数组、哈希表和字典)的集合。
    System.Collections.Generic 命名空间包含定义泛型集合的接口和类,泛型集合允许用户创建强类型集合,它能提供比非泛型强类型集合更好的类型安全性和性能。
    System.Collections.Specialized 命名空间包含专用的和强类型的集合,例如,链接的列表词典、位向量以及只包含字符串的集合。

    泛型最常见的用途是泛型集合,命名空间System.Collections.Generic 中包含了一些基于泛型的集合类,使用泛型集合类可以提供更高的类型安全性,还有更高的性能,避免了非泛型集合的重复的装箱和拆箱。
    很多非泛型集合类都有对应的泛型集合类,我觉得最好还是养成用泛型集合类的好习惯,他不但性能上好而且 功能上要比非泛型类更齐全。下面是常用的非泛型集合类以及对应的泛型集合类:

    非泛型集合类 泛型集合类
    ArrayList List<T>
    HashTable DIctionary<T>
    Queue Queue<T>
    Stack Stack<T>
    SortedList SortedList<T>

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

    Hashtable 用法

    在 .NET Framework 中, Hashtable 是 System.Collections 命名空间提供的一个容器,用于处理和表现类似 key/value 的键值对,其中 key 通常可用来快速查找,同时 key 是区分大小写; value 用于存储对应于 key 的值。 Hashtable 中 key/value 键值对均为 object 类型,所以 Hashtable 可以支持任何类型的 key/value 键值对 . 。

    在哈希表中添加一个 key/value 键值对: HashtableObject.Add(key,value);
    在哈希表中去除某个 key/value 键值对: HashtableObject.Remove(key);
    从哈希表中移除所有元素: HashtableObject.Clear();
    判断哈希表是否包含特定键 key : HashtableObject.Contains(key);



    Hashtable ht = new Hashtable ();

    ht .Add ("a" , 123);

    ht .Add ("b" , 456);


    // 遍历哈希表需要用到DictionaryEntry Object

    foreach (DictionaryEntry de in ht )

    {

    MessageBox .Show (de .Key .ToString () + " " + de .Value .ToString ());

    }



    // 对哈希表进行排序

    ArrayList akeys = new ArrayList (ht .Keys ); // 别忘了导入System.Collections

    akeys .Sort (); // 按字母顺序进行排序

    foreach (string skey in akeys )

    {
    MessageBox .Show (skey + ":" );

    MessageBox .Show (ht [skey ].ToString ());// 排序后输出

    }

    ArrayList 用法

    private static void AddToList (ArrayList list , string p )

    {

    if (list .Contains (p ) == false )

    list .Add (p );

    }



    private void button1_Click (object sender , EventArgs e )

    {

    ArrayList list = new ArrayList ();

    AddToList (list , "Table1" );

    AddToList (list , "Table4" );

    AddToList (list , "Table1" );

    AddToList (list , "Table3" );

    AddToList (list , "Table2" );

    AddToList (list , "Table2" );



    foreach (string s in list )

    {

    MessageBox .Show (s );

    }

    }

    List

    List <string > listStr = new List <string >();

    listStr .Add ("123" );

    listStr .Add ("456" );

    listStr .Add ("789" );

    MessageBox .Show (listStr [2]);// ” 789 ”



    Dictionary

    泛型的优点( C# 编程指南)

    C# 中典型的范型结构除了熟悉的 IList , HashTable 之外还有一个并不常见的Dictionary 集合。

    相比较而言,Dictionary 的性能是最好的,也属于轻便型的集合。效率要大于HashTable ,其主要原因是Dictionary 支持强类型声明的。

    在公共语言运行库和 C# 语言的早期版本中,通用化是通过在类型与通用基类型 Object 之间进行强制转换来实现的,泛型提供了针对这种限制的解决方案。通过创建泛型类,您可以创建一个在编译时类型安全的集合。

    添加到 ArrayList 中的任何引用或值类型都将隐式地向上强制转换为 Object 。如果项是值类型,则必须在将其添加到列表中时进行装箱操作,在检索时进行取消装箱操作。强制转换以及装箱和取消装箱操作都会降低性能;在必须对大型集合进行循环访问的情况下,装箱和取消装箱的影响非常明显。

    对于客户端代码,与 ArrayList 相比,使用 List<T> 时添加的唯一语法是声明和实例化中的类型参数。虽然这稍微增加了些编码的复杂性,但好处是您可以创建一个比 ArrayList 更安全并且速度更快的列表,特别适用于列表项是值类型的情况。

    Dictionary 泛型类提供了从一组键到一组值的映射。字典中的每个添加项都由一个值及其相关联的键组成。通过键来检索值的速度是非常快的,接近于 O(1) ,这是因为 Dictionary 类是作为一个哈希表来实现的。

    1 、

    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 )

    {

    MessageBox .Show (" 键是:" +i .ToString ()+ " 值是:" + fruit [i ]);

    }

    2 、

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



    // 加入重复键会引发异常

    fruit .Add ("1" , " 苹果" );

    fruit .Add ("2" , " 桔子" );

    fruit .Add ("3" , " 香蕉" );

    fruit .Add ("4" , " 菠萝" );



    // 因为引入了泛型,所以键取出后不需要进行Object 到int 的转换,

    值的集合也一样

    foreach (string i in fruit .Keys )

    {

    MessageBox .Show (" 键是:" +i .ToString ()+ " 值是:" + fruit [i ]);

    }
    Hashtable 和 Dictionary
    Hashtable 和 Dictionary

    1:多线程程序中推荐使用 Hashtable, 默认的 Hashtable 允许单线程写入, 多线程读取, 对 Hashtable 进一步调用 Synchronized() 方法可以获得完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用 lock 语句进行保护, 效率大减.

    2:单线程程序中推荐使用 Dictionary, 有泛型优势, 且读取速度较快, 容量利用更充分.
    3:Dictionary 有按插入顺序排列数据的特性 (注: 但当调用 Remove() 删除过节点后顺序被打乱), 因此在需要体现顺序的情境中使用 Dictionary 能获得一定方便.



    Hashtable类和 Dictionary<(Of <(TKey, TValue>)>) 泛型类实现 IDictionary 接口

    Dictionary<(Of <(TKey, TValue>)>) 泛型类还实现 IDictionary<(Of <(TKey, TValue>)>) 泛型接口。因此,这些集合中的每个元素都是一个键/值对。

    Dictionary<(Of <(TKey, TValue>)>) 类与 Hashtable 类的功能相同
    对于值类型,特定类型(不包括 Object)的 Dictionary<(Of <(TKey, TValue>)>) 的性能优于 Hashtable,这是因为 Hashtable 的元素属于 Object 类型,所以在存储或检索值类型时通常发生装箱和取消装箱操作。

    Hashtableht=new Hashtable();//实现 IDictionary接口
    ht.Add(1,"A");
    ht.Add(2,"B");
    ht.Add(3,"c");
    foreach(DictionaryEntry de in ht)//Hashtable返回的是DictionaryEntry 类型
    {
    de.Key;
    de.Value;
    }

    Dictionary<int,string> myDictionary=new Dictionary<int,string>();//实现IDictionary接口,IDictionary<T key,T value>类
    myDictionary.Add(1,"a");
    myDictionary.Add(2,"b");
    myDictionary.Add(3,"c");
    foreach(int i in myDictionary.Keys)
    {
    Console.WriteLine("Key="+i+"Value="+myDictionary);
    }
    Or
    foreach(KeyValuePair<string, double> temp in myDictionary)//返回的是KeyValuePair<string, double>泛型数组
    {
    temp.Key;
    temp.Value;
    }


    展开全文
  • Array Arraylist 区别

    2019-07-04 22:07:49
    有些知识点可能平时一直在使用,...数组、List和ArrayList的区别:  数组在内存中是连续存储的,所以它的索引速度是非常的快,而且赋值与修改元素也很简单,比如: string[] s=new string[3]; //赋值 s[0]=“a”; ...

    有些知识点可能平时一直在使用,不过实际开发中我们可能只是知其然不知其所以然,所以经常的总结会对我们的提高和进步有很大的帮助,这里记录自己在工作之余的问题,持续更新,欢迎高手斧正.

    数组、List和ArrayList的区别:
      数组在内存中是连续存储的,所以它的索引速度是非常的快,而且赋值与修改元素也很简单,比如:
    string[] s=new string[3];
    //赋值
    s[0]=“a”; s[1]=“b”; s[2]=“c”;
    //修改
    s[1]=“b1”;
      但是数组也存在一些不足的地方。比如在数组的两个数据间插入数据也是很麻烦的,还有我们在声明数组的时候,必须同时指明数组的长度,数组的长度过长,会造成内存浪费,数组和长度过短,会造成数据溢出的错误。这样如果在声明数组时我们并不清楚数组的长度,就变的很麻烦了。C#中最先提供了ArrayList对象来克服这些缺点。
      ArrayList是.Net Framework提供的用于数据存储和检索的专用类,它是命名空间System.Collections下的一部分。它的大小是按照其中存储的数据来动态扩充与收缩的。所以,我们在声明ArrayList对象时并不需要指定它的长度。ArrayList继承了IList接口,所以它可以很方便的进行数据的添加,插入和移除.比如:
    复制代码
    ArrayList list = new ArrayList();
    //新增数据
    list.Add(“abc”); list.Add(123);
    //修改数据
    list[2] = 345;
    //移除数据
    list.RemoveAt(0);
    //插入数据
    list.Insert(0, “hello world”);
    复制代码
      从上面示例看,ArrayList好像是解决了数组中所有的缺点,那么它应该就是完美的了,为什么在C#2.0后又会出现List呢?
       在list中,我们不仅插入了字符串"abc",而且又插入了数字123。这样在ArrayList中插入不同类型的数据是允许的。因为ArrayList会把所有插入其中的数据都当作为object类型来处理。这样,在我们使用ArrayList中的数据来处理问题的时候,很可能会报类型不匹配的错误,也就是说ArrayList不是类型安全的。既使我们保证在插入数据的时候都很小心,都有插入了同一类型的数据,但在使用的时候,我们也需要将它们转化为对应的原类型来处理。这就存在了装箱与拆箱的操作,会带来很大的性能损耗。
      装箱与拆箱的概念: 简单的来讲: 装箱:就是将值类型的数据打包到引用类型的实例中 比如将int类型的值123赋给object对象o

    int i=123; object o=(object)i;

    拆箱:就是从引用数据中提取值类型 比如将object对象o的值赋给int类型的变量

    object o=123; int i=(int)o;

    装箱与拆箱的过程是很损耗性能的。
      正是因为ArrayList存在不安全类型与装箱拆箱的缺点,所以在C#2.0后出现了泛型的概念。而List类是ArrayList类的泛型等效类。它的大部分用法都与ArrayList相似,因为List类也继承了IList接口。最关键的区别在于,在声明List集合时,我们同时需要为其声明List集合内数据的对象类型。 比如:

    复制代码
    List list = new List();
    //新增数据
    list.Add(123);
    //修改数据
    list[0] = 345;
    //移除数据
    list.RemoveAt(0);
    复制代码
      上例中,如果我们往List集合中插入string字符"hello world",IDE就会报错,且不能通过编译。这样就避免了前面讲的类型安全问题与装箱拆箱的性能问题了。

    同时 List不能被构造,但可以向上面那样为List创建一个引用,而ListArray就可以被构造。

    List list; //正确 list=null;
    List list=new List(); // 是错误的用法
      List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了,有些ArrayList有但是List没有的属性和方法,它就不能再用了。 而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。

    List泛型的好处:
      通过允许指定泛型类或方法操作的特定类型,泛型功能将类型安全的任务从您转移给了编译器。不需要编写代码来检测数据类型是否正确,因为会在编译时强制使用正确的数据类型。减少了类型强制转换的需要和运行时错误的可能性。泛型提供了类型安全但没有增加多个实现的开销。
    参考
    Array, ArrayList之间的转换,( arraylist.toArray() , Arrays.asList( arr ) ArrayList arrlist = new ArrayList();
      arrlist.add(“2223”);
      arrlist.add(“eeeeee”);
    arrlist.toArray();
    List list=Arrays.asList(array);

    展开全文
  • java array arraylist

    2014-03-20 17:03:20
    可以将 ArrayList想象成一种“会自动扩增容量的Array”。 2)Array([]):最高效;但是其容量固定且无法动态改变;  ArrayList: 容量可动态增长;但牺牲效率; 3)建议: 基于效率和类型检验,应尽可能...

    1)精辟阐述:
    可以将 ArrayList想象成一种会自动扩增容量的Array”

    2Array[]):最高效;但是其容量固定且无法动态改变;
         ArrayList: 容量可动态增长;但牺牲效率;

    3)建议:
    基于效率和类型检验,应尽可能使用Array无法确定数组大小时才使用ArrayList
    不过当你试着解决更一般化的问题时,Array的功能就可能过于受限。

    4Java中一切皆对象,Array也是对象。不论你所使用得Array型别为何,

    Array名称本身实际上是个reference,指向heap之内得某个实际对象。

    这个对象可经由“Array初始化语法被自动产生,也可以以new表达式手动产生。

    5Array可做为函数返回值,因为它本身是对象的reference

    6)对象数组与基本类型数组在运用上几乎一模一样,唯一差别在于,前者持有得是reference,后者直接持有基本型别之值;
    例如:
    string [] staff=new string[100];
    int [] num=new int[10];

    7
    )容器所持有的其实是一个个reference指向Object,进而才能存储任意型别。当然这不包括基本型别,因为基本型别并不继承自任何classes

    8)面对Array,我们可以直接持有基本型别数值的Array(例如:int[] num;),也可以持有reference(指向对象)的Array;但是容器类仅能持有reference(指向对象),若要将基本型别置于容器内,需要使用wrapper类。但是wrapper类使用起来可能不很容易上手,此外,primitivesArray的效率比起容纳基本型别之外覆类(的reference的容器好太多了。

    当然,如果你的操作对象是基本型别,而且需要在空间不足时自动扩增容量,Array便不适合,此时就得使用外覆类的容器了。

    9)某些情况下,容器类即使没有转型至原来的型别,仍然可以运作无误。有一种情况尤其特别:编译器对Stringclass提供了一些额外的支持,使它可以平滑运作。

    10)对数组的一些基本操作,像排序、搜索与比较等是很常见的。因此在Java中提供了Arrays类协助这几个操作:sort(),binarySearch(),equals(),fill(),asList().

    不过Arrays类没有提供删除方法,而ArrayList中有remove()方法,不知道是否是不需要在Array中做删除等操作的原因(因为此时应该使用链表)。

    11ArrayList的使用也很简单:产生ArrayList,利用add()将对象置入,利用get(i)配合索引值将它们取出。这一切就和Array的使用方式完全相同,只不过少了[]而已。

    2.参考资料:
    1)效率:
    数组扩容是对ArrayList效率影响比较大的一个因素。
    每当执行AddAddRangeInsertInsertRange等添加元素的方法,都会检查内部数组的容量是否不够了,如果是,它就会以当前容量的两倍来重新构建一个数组,将旧元素Copy到新数组中,然后丢弃旧数组,在这个临界点的扩容操作,应该来说是比较影响效率的。

    ArrayListArray的复杂版本
    ArrayList内部封装了一个Object类型的数组,从一般的意义来说,它和数组没有本质的差别,甚至于ArrayList的许多方法,如IndexIndexOfContainsSort等都是在内部数组的基础上直接调用Array的对应方法。

    2)类型识别:
    ArrayList存入对象时,抛弃类型信息,所有对象屏蔽为Object,编译时不检查类型,但是运行时会报错。
    ArrayList与数组的区别主要就是由于动态增容的效率问题了

    3ArrayList可以存任何Object,如String等。

    展开全文
  • 2.array 数组在内存中是一段连续的地址,且大小在生成时必须指定大小,且里面的类型必须全部保持一致。 3.arraylist 是list接口的实现类,但是在new时可以不指定数组大小,默认大小为10,超出容量后 ,扩大到2倍。...

    1.在java中,list是个接口,不能直接new,只能用它的子类来指向它。

    2.array  数组在内存中是一段连续的地址,且大小在生成时必须指定大小,且里面的类型必须全部保持一致。

    3.arraylist 是list接口的实现类,但是在new时可以不指定数组大小,默认大小为10,超出容量后 ,扩大到2倍。如果不使用泛型类声明Arraylist,那么在arraylist可以放不同的类型,如:ArrayList  list=new ArrayList();这样是类型不安全的。

    ArrayList里面的默认类型是Object,如果是引用类型,就需要强转,如果是值类型,如:int i=2;这种类型,就需要装箱和拆箱,这样会有性能的消耗。

    当使用list的时候,推荐使用泛型 如List<String> list=new ArrayList<String>;这样就不存在类型不一致的问题。

    展开全文
  • C# 集合类 Array Arraylist List Hashtable Dictionary Stack Queue 数组是固定大小的,不能伸缩。虽然System.Array.Resize这个泛型方法可以重置数组大小,但是该方法是重新创建新设置大小的数组,用的是旧数组的...
  • ArrayArrayList、LinkList之间的区别:ArrayArrayList、LinkList均属于泛型的范畴,都用来存放元素,主要区别是Array是一个固定大小的容器,底层采用的是线性连续空间来存放元素,ArrayList同样也是一个容器,...
  • ArrayArrayList、LinkList之间的区别:ArrayArrayList、LinkList均属于泛型的范畴,都用来存放元素,主要区别是Array是一个固定大小的容器,底层采用的是线性连续空间来存放元素,ArrayList同样也是一个容器,...
  • ArrayList LinkedList Vector 随机访问操作(get) 16 23 63 31 迭代操作(Iterate) 31 47 33 48 插入操作(insert) 不适用 1610 31 1625 删除操作(delete) 不适用 6625 16 6750 ...
  • 数组 à  集合 à 泛型集合   写法 说明 数组 Int[] arrInt; 固定大小, 固定元素类型 ...arrayList hashtable SortedList 可变长度 Object类型 泛型集合 List Diction
  • * 输入描述:而ArrayList实际上是C#中的“动态数组”,ArrayList中的数组元素的个数是可以改变的。 * 输入描述:元素可以随意添加、插入或移除。编写一个控制台应用实验这两个常用数组类。 * 问题描述: * 程序...
  • ArrayArrayList不同

    2017-03-17 16:44:00
    Employee[] array = new Employee[10]; ArrayList<Employee> staff = new ArrayList<>(); 不同 Array ArrayList 利弊 长度是否可变 长度不可变array的长度一直为10 长度可变,通过add...
  • Today we will learn how to create a Java array of ArrayList. We will also learn how to create an ArrayList of array elements. 今天,我们将学习如何创建ArrayList的Java数组。 我们还将学习如何创建数组元素...
  • Array可以包含基本类型和对象类型,ArrayList只能包含对象类型。 ②Array大小是固定的,ArrayList的大小是动态变化的。 ArrayList提供了更多的方法和特性,比如:addAll(),removeAll(),iterator()等等。 ...
  • C# ArrayArrayList区别 C# ArrayArrayList区别 一,C# array数组的用法范例: type[] typename=new type[size]; 如int[] a=new int[2];string[] str=new string[5]; 实事上我们平常是...
  • Array&Arraylist

    2018-05-21 12:25:34
    [ArrayArrayList的区别]#1. Array类型的变量在声明的同时必须进行实例化(至少得初始化数组的大小),而ArrayList可以只是先声明。如: int[] array = new array[3]; 或 int[] array = {1,2,3}; 或 ArrayList ...
  • Array and ArrayList

    2019-10-04 23:12:22
    1)精辟阐述:可以将ArrayList想象成一种“会自动扩增容量的Array”。2)Array([]):最高效;但是其容量固定且无法动态改变;ArrayList:容量可动态增长;但牺牲效率;3)建议:基于效率和类型检验,应尽可能使用...
  • arrayarraylist

    2020-09-11 11:11:33
    通常讲集合类 (Collection) 是指ArrayList, LinkedList, 等。常用集合如:List, Set, Map. array创建好后它的空间是固定的. 而集合的空间是可变的. array外部需要标明primitive type, 而list内部需要标明wrapper...
  • ArrayArrayList

    2019-06-20 09:26:42
    可以将ArrayList想象成一种“会自动扩增容量的Array”。 2)建议: 基于效率和类型检验,应尽可能使用Array,无法确定数组大小时才使用ArrayList! 不过当你试着解决更一般化的问题时,Array的功能就可能过于受限...
  • ArrayArrayList 的区别

    千次阅读 2019-05-06 11:38:33
    ArrayArrayList 有何区别? Array 即数组,声明方式可以如下: int[] array = new int[3]; int array [] = new int[3]; int[] array = {1, 2, 3}; int[] array = new int[]{1, 2, 3}; 定义一个 Array 时...
  • ArrayArrayList区别

    2019-10-16 22:38:48
    Array可以包括基本类型和对象类型,而ArrayList只能包括对象类型。 Array的大小是固定的,而ArrayList的大小是可以动态变化的。 简单来说,ArrayList是一个长度可以自动增长的Array 其实上面一句话就道尽了两者最...
  • ArrayArrayList

    热门讨论 2019-12-08 08:20:15
    Array(数组) 所谓数组,是有序的元素序列。 若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的...
  • Array转换ArrayList

    2013-05-04 15:45:00
    1. Foreach 2. ArrayList.Adapter. ...3. ArrayList to Array. 强制转换Array result = (int[])arrayList.ToArray(typeof(int)) View Code class Program { static void Main(string[] args) ...
  • 在C#里把ArrayList转换为Array或 把Array转换为ArrayList原文地址:http://www.dotnetspider.com/kb/Article1709.aspx 06 日Dec, 2005 年 作者: Aldwin Enriquez Narrasoft 菲律宾公司。 概述 这篇文章解释如何使用最...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,914
精华内容 3,165
关键字:

arrayarraylist