首先說明C#中的Array類：Array 類是 C# 中所有數組的基類，它是在 System 命名空間中定義。Array 類提供了各種用於數組的屬性和方法。關於Array類的一些屬性及方法詳見博文：C#中的HashTable和Array類：http://www.cnblogs.com/newcapecjmc/p/7099947.html
數組
數組在C#中最早出現的。在內存中是連續存儲的，所以它的索引速度非常快，而且賦值與修改元素也很簡單。
- <span style="font-family: SimSun; font-size: 18px;">//數組
- string[] s=new string[2];
- //賦值
- s[0]="a";
- s[1]="b";
- //修改
- s[1]="a1";
- </span>
//數組
string[] s=new string[2];
//賦值
s[0]="a";
s[1]="b";
//修改
s[1]="a1";
但是數組存在一些不足的地方。在數組的兩個數據間插入數據是很麻煩的，而且在聲明數組的時候必須指定數組的長度，數組的長度過長，會造成內存浪費，過段會造成數據溢出的錯誤。如果在聲明數組時我們不清楚數組的長度，就會變得很麻煩。
針對數組的這些缺點，C#中最先提供了ArrayList對象來克服這些缺點。
ArrayList
ArrayList是命名空間"font-family: SimSun; font-size: 18px;">//ArrayList
- ArrayList list1 = new ArrayList();
- //新增數據
- list1.Add("cde");
- list1.Add(5678);
- //修改數據
- list[2] = 34;
- //移除數據
- list.RemoveAt(0);
- //插入數據
- list.Insert(0, "qwe");
- </span>
//ArrayList
ArrayList list1 = new ArrayList();
//新增數據
list1.Add("cde");
list1.Add(5678);
//修改數據
list[2] = 34;
//移除數據
list.RemoveAt(0);
//插入數據
list.Insert(0, "qwe");
從上面例子看，ArrayList好像是解決了數組中所有的缺點，為什么又會有List？
我們從上面的例子看，在List中，我們不僅插入了字符串cde，而且插入了數字5678。這樣在ArrayList中插入不同類型的數據是允許的。因為ArrayList會把所有插入其中的數據當作為object類型來處理，在我們使用ArrayList處理數據時，很可能會報類型不匹配的錯誤，也就是ArrayList不是類型安全的。在存儲或檢索值類型時通常發生裝箱和取消裝箱操作，帶來很大的性能耗損。
裝箱與拆箱的概念： 簡單的說: 裝箱：就是將值類型的數據打包到引用類型的實例中 比如將string類型的值abc賦給object對象obj
- <span style="font-family: SimSun; font-size: 18px;">String i=”abc”;
- object obj=(object)i;
- </span>
String i=”abc”;
object obj=(object)i;
拆箱：就是從引用數據中提取值類型 比如將object對象obj的值賦給string類型的變量i
- <span style="font-family: SimSun; font-size: 18px;">object obj=”abc”;
- string i=(string)obj;
- </span>
object obj=”abc”;
string i=(string)obj;
裝箱與拆箱的過程是很損耗性能的。
補充：
Array的用法與數組幾乎一樣，可以看做是數組。在定義的時候需要指定長度；ArrayList的用法與普通集合一樣，定義的時候不需要指定長度；
如：Array[] animalArray = new Array[2];
ArrayList animalArrayList = new ArrayList();
泛型List
因為ArrayList存在不安全類型與裝箱拆箱的缺點，所以出現了泛型的概念。List類是ArrayList類的泛型等效類，它的大部分用法都與ArrayList相似，因為List類也繼承了IList接口。最關鍵的區別在於，在聲明List集合時，我們同時需要為其聲明List集合內數據的對象類型。
比如：
- <span style="font-family: SimSun; font-size: 18px;">List<string> list = new List<string>();
- //新增數據
- list.Add(“abc”);
- //修改數據
- list[0] = “def”;
- //移除數據
- list.RemoveAt(0);
- </span>
List<string> list = new List<string>();
//新增數據
list.Add(“abc”);
//修改數據
list[0] = “def”;
//移除數據
list.RemoveAt(0);
上例中，如果我們往List集合中插入int數組123，IDE就會報錯，且不能通過編譯。這樣就避免了前面講的類型安全問題與裝箱拆箱的性能問題了。
補充：
總結：
數組的容量是固定的，您只能一次獲取或設置一個元素的值，而ArrayList或List<T>的容量可根據需要自動擴充、修改、刪除或插入數據。
數組可以具有多個維度，而 ArrayList或 List< T> 始終只具有一個維度。但是，您可以輕松創建數組列表或列表的列表。特定類型（Object 除外）的數組 的性能優於 ArrayList的性能。 這是因為 ArrayList的元素屬於 Object 類型；所以在存儲或檢索值類型時通常發生裝箱和取消裝箱操作。不過，在不需要重新分配時（即最初的容量十分接近列表的最大容量），List< T> 的性能與同類型的數組十分相近。
在決定使用 List<T> 還是使用ArrayList 類（兩者具有類似的功能）時，記住List<T> 類在大多數情況下執行得更好並且是類型安全的。如果對List< T> 類的類型T 使用引用類型，則兩個類的行為是完全相同的。但是，如果對類型T使用值類型，則需要考慮實現和裝箱問題。
數組：（1）在聲明數組時必須指定數組的大小，過長浪費內存，過短內存溢出（2）在數組中的兩個數之間插入數據比較麻煩。
ArrayList（繼承了IList接口）：可以插入不同的值類型，在數據檢索及存儲時存在裝箱與拆箱操作，容易帶來性能消耗。
List（繼承了IList接口）：在聲明List集合時，我們同時需要為其聲明List集合內數據的對象類型，避免了裝箱與拆箱動作。
補充：
list<T>類可表示可通過索引訪問的對象的強制類型列表，提供用於對列表進行搜索、排序和操作的方法。
作用：泛型最常見的用途是泛型集合。
List的一般用法：所屬命名空間：System.Collection.Generic
public class List<T>:IList<T>,Icollection<T>,IEnumerable<T>,IList,Icollection,Ienumerable
List<T>是ArrayList類的泛型等效類，該類使用大小可按需動態增加的數組實現IList<T>泛型接口。
(1)聲明 List<T>mlist = new List<T>(); eg: string[] Arr = {"a","b","c"}; List<string> mlist = new List<string>(Arr);
(2)添加一個元素 List.Add(T item) eg: mlist.Add("d");
(3)添加集合元素 eg: string[] Arr2 ={"f","g"."h"}; mlist.AddRange(Arr2);
(4)在index位置添加一個元素 Insert(int index,T item) eg: mlist.Insert(1,"p");
(5)遍歷List中元素
foreach(T element in mlist) T的類型與mlist聲明時一樣 { Console.WriteLine(element); }
eg: foreach(string s in mlist) { Console.WriteLine(s); }
(6)刪除元素
List.Remove(T item) 刪除一個值 eg: mlist.Remove("a");
List.RemoveAt(int index);刪除下標為index的元素 eg: mlist.RemoveAt(0); List.RemoveRange(int index,int count); 下標index開始，刪除count個元素 eg：mlist.RemoveRange(3,2);
(7)判斷某個元素是否在該List中
List.Contains(T item) 返回true或false eg: if(mlist.Contains"("g")) Console.WriteLine("g存在列表中"); else mlist.Add("g");
(8)給List里面元素排序 List.Sort() 默認是元素每一個字母按升序 eg: mlist.Sort();
(9)給List里面元素順序反轉 List.Reverse() 可以與List.Sort()配合使用
(10)List清空 List.Clear() eg: mlist.Clear();
(11)獲得List中元素數目 List.Count() 返回int值 eg: mlist.count();
List進階，強大方法
(1)List.FindAll方法：檢索與指定謂詞所定義的條件相匹配的所有元素 class program { static void Main(stirng[] args) { student stu = new student(); stu.Name="arron"; List<student> students= new List<student>(); students.Add(stu); students.Add(new student("candy")); FindName myname = new FindName("arron"); foreach(student s in students.FindAll(new Predicate<student>(myname.IsName))) { Console.WriteLine(s);} }
public class student { public string Name{get;set;} public student(){} public override string ToString() { return string.Format("姓名:{0}",Name); } }
public class FindName { private string _name; public FindName(string Name) { this._name=Name;} public bool IsName(student s) { return (s.Name==_name)?true:false;} }
(2)List.Find方法 搜索與指定謂詞所定義的條件相匹配的元素，並返回整個List中的第一個匹配元素
eg:
//Predicate是對方法的委托，如果傳遞給它的對象與委托定義的條件匹配，則該方法返回true,當前List的元素 被逐個傳遞給Predicate委托，並在List中間前移動，從第一個元素開始，到最后一個元素結束，當找到匹配項 時處理停止
第一種方法 委托給拉姆達表達式： eg: string listFind = mlist.Find(name=> { if(name.length>3) return true; return false; });
第二種方法 委托給一個函數 eg: public bool ListFind(string name)
{
if (name.Length > 3)
{
return true;
}
return false;
}
這兩種方法的結果是一樣的
(3) List.FindLast方法 public T FindLast(Predicate<T> match);確定是否 List 中的每個元素都與指定的謂詞所定義的條件相匹配。用法與List.Find相同。
(4) List.TrueForAll方法： 確定是否 List 中的每個元素都與指定的謂詞所定義的條件相匹配。
public bool TrueForAll(Predicate<T> match);
(5) List.Take(n)： 獲得前n行 返回值為IEnumetable<T>，T的類型與List<T>的類型一樣
E.g.：
IEnumerable<string> takeList= mList.Take(5);
foreach (string s in takeList)
{
Console.WriteLine("element in takeList: " + s);
}
這時takeList存放的元素就是mList中的前5個
(6) List.Where方法：檢索與指定謂詞所定義的條件相匹配的所有元素。跟List.FindAll方法類似。
E.g.：
IEnumerable<string> whereList = mList.Where(name =>
{
if (name.Length > 3)
{
return true;
}
else
{
return false;
}
});
foreach (string s in subList)
{
Console.WriteLine("element in subList: "+s);
}
這時subList存儲的就是所有長度大於3的元素
(7)List.RemoveAll方法：移除與指定的謂詞所定義的條件相匹配的所有元素。
public int RemoveAll(Predicate<T> match);
E.g.：
mList.RemoveAll(name =>
{
if (name.Length > 3)
{
return true;
}
else
{
return false;
}
});
foreach (string s in mList)
{
Console.WriteLine("element in mList: " + s);
}
這時mList存儲的就是移除長度大於3之后的元素。
以下博文參考：
數組、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類型的變量i
object o=123; int i=(int)o;
裝箱與拆箱的過程是很損耗性能的。
正是因為ArrayList存在不安全類型與裝箱拆箱的缺點，所以在C#2.0后出現了泛型的概念。而List類是ArrayList類的泛型等效類。它的大部分用法都與ArrayList相似，因為List類也繼承了IList接口。最關鍵的區別在於，在聲明List集合時，我們同時需要為其聲明List集合內數據的對象類型。 比如：
List<int> list = new List<int>(); //新增數據 list.Add(123); //修改數據 list[0] = 345; //移除數據 list.RemoveAt(0);
上例中，如果我們往List集合中插入string字符"hello world"，IDE就會報錯，且不能通過編譯。這樣就避免了前面講的類型安全問題與裝箱拆箱的性能問題了。
同時 List不能被構造，但可以向上面那樣為List創建一個引用，而ArrayList就可以被構造。
List list; //正確 list=null; List list=new List(); // 是錯誤的用法
List list = new ArrayList();這句創建了一個ArrayList的對象后把上溯到了List。此時它是一個List對象了，有些ArrayList有但是List沒有的屬性和方法，它就不能再用了。 而ArrayList list=new ArrayList();創建一對象則保留了ArrayList的所有屬性。
List泛型的好處： 通過允許指定泛型類或方法操作的特定類型，泛型功能將類型安全的任務從您轉移給了編譯器。不需要編寫代碼來檢測數據類型是否正確，因為會在編譯時強制使用正確的數據類型。減少了類型強制轉換的需要和運行時錯誤的可能性。泛型提供了類型安全但沒有增加多個實現的開銷。
https://www.cnblogs.com/newcapecjmc/p/6970220.html