C#集合--數組

Array類是所有一維和多維數組的隱式基類，同時也是實現標准集合接口的最基本的類型。Array類實現了類型統一，因此它為所有數組提供了一組通用的方法，不論這些數組元素的類型，這些通用的方法均適用。

正因為數組如此重要，所以C#為聲明數組和初始化數組提供了明確的語法。在使用C#語法聲明一個數組時，CLR隱式地構建Array類--合成一個偽類型以匹配數組的維數和數組元素的類型。而且這個偽類型實現了generic集合接口，比如IList<string>接口。

CLR在創建數組類型實例時會做特殊處理--在內存中為數組分配連續的空間。這就使得索引數組非常高效，但這卻阻止了對數組的修改或調正數組大小。

Array類實現了IList<T>接口和IList接口。Array類顯示地實現了IList<T>接口，這是為了保證接口的完整性。但是在固定長度集合比如數組上調用IList<T>接口的Add或Remove方法時，會拋出異常（因為數組實例一旦聲明之后，就不能更改數組的長度）。Array類提供了一個靜態的Resize方法，使用這個方法創建一個新的數組實例，然后復制當前數組的元素到新的實例。此外，在程序中，當在任何地方引用一個數組都會執行最原始版本的數組實例。因此如果希望集合大小可以調整，那么你最好使用List<T>類。

數組元素可以是值類型也可以是引用類型。值類型數組元素直接存在數組中，比如包含3個整數的數組會占用24個字節的連續內存。而引用類型的數組元素，占用的空間和一個引用占用的空間一樣（32位環境中4個字節，64為環境中8個字節）。我們先來看下面的代碼：

int[] numbers =new int[3];
numbers[0] =1;
numbers[1] = 7;

StringBuilder[] builders = new StringBuilder[5];
builders[0] = new StringBuilder("Builder1");
builders[1] = new StringBuilder("Builder2");
builders[2] = new StringBuilder("Builder3");

對應的內存分配變化如下面幾張圖所示：

執行完int[] numbers=new int[3]之后，在內存中分配了8×3=24個字節，每個字節都為0。

執行完numbers[0]=1之后，數組聲明后的第一個8字節變為00 00 00 01。

 

同樣地，執行完numbers[1]=7之后，第二段8個字節變為00 00 00 07。

對應引用類型的數組，我們用一張圖來說明內存分配：

看起來分復雜，其實內存分配示意圖如下

 

通過Clone方法可以克隆一個數組，比如arrayB = arrayA.Clone()。但是，克隆數組執行淺拷貝，也就是說數組自己包含的那部分內容才會被克隆。簡單說，如果數組包含的是值類型對象，那么克隆了這些對象的值。而數組的子元素是引用類型，那么僅僅克隆引用類型的地址。

StringBuilder[] builders2 = builders;
ShtringBuilder[] shallowClone = (StringBuilder[])builders.Clone();

與之對應的內存分配示意圖：

如果需要執行深拷貝，即克隆引用類型的子對象；那么你需要遍歷數組並手動的克隆每個數組元素。深克隆規則也適用於.NET其他集合類型。

盡管數組在設計時，主要使用32位的索引，它也在一定程度上支持64位索引，這需要使用那些既接收Int32又接收Int64類型參數的方法。這些重載方法在實際中並沒有意義，因為CLR不允許任何對象--包括數組在內--的大小超過2G（無論32位的系統還是64位的系統）

 

構造數組和索引數組

創建數組和索引數組的最簡單方式就是通過C#語言的構建器

Int[] myArray={1,2,3};
int first=myArray[0];
int last = myArray[myArray.Length-1];

或者，你可以通過調用Array.CreateInstance方法動態地創建一個數組實例。你可以通過這種方式指定數組元素的類型和數組的維度。而GetValue和SetValue方法允許你訪問動態創建的數組實例的元素。

Array a = Arrat.CreateInstance(typeof(string), 2);
a.SetValue('hi", 0);
a.SetValue("there",1);
string s  = (string)a.getValue(0);

string[] cSharpArray = (string[])a;
string s2  = cSharpArray[0];

動態創建的零索引的數組可以轉換為一個匹配或兼容的C＃數組。比如，如果Apple是Fruit的子類，那么Apple[]可以轉換成Fruit[]。這也是為什么object[]沒有作為統一的數組類型，而是使用Array類；答案在於object[]不僅與多維數組不兼容，而且還與值類型數組不兼容。因此我們使用Array類作為統一的數組類型。

GetValue和SetValue對編譯器生成的數組也起作用，若想編寫一個方法處理任何類型的數組和任意維度的數組，那么這兩個方法非常有用。對於多維數組，這兩個方法可以把一個數組當作索引參數。

public object GetValue(params int[] indices)
public void SetValue(object value, params int[] indices)

下面的方法在屏幕打印任意數組的第一個元素，無論數組的維度

void WriteFirstValue (Array a)
{
Console.Write (a.Rank + "-dimensional; ");
 
int[] indexers = new int[a.Rank];
Console.WriteLine ("First value is " + a.GetValue (indexers));
}
void Demo()
{
int[] oneD = { 1, 2, 3 };
int[,] twoD = { {5,6}, {8,9} };
WriteFirstValue (oneD); // 1-dimensional; first value is 1
WriteFirstValue (twoD); // 2-dimensional; first value is 5
}

在使用SetValue方法時，如果元素與數組類型不兼容，那么會拋出異常。

無論采取哪種方式實例化一個數組之后，那么數組元素自動初始化了。對於引用類型元素的數組而言，初始化數組元素就是把null值賦給這些數組元素；而對於值類型數組元素，那么會把值類型的默認值賦給數組元素。此外，調用Array類的Clear方法也可以完成同樣的功能。Clear方法不會影響數組大小。這和常見的Clear方法（比如ICollection<T>.Clear方法）不一樣，常見的Clear方法會清除集合的所有元素。

 

遍歷數組

通過foreach語句，可以非常方便地遍歷數組：

int[] myArray = { 1, 2, 3};
foreach (int val in myArray)
    Console.WriteLine (val);

你還可以使用Array.ForEach方法來遍歷數組

public static void ForEach<T> (T[] array, Action<T> action);

該方法使用Action代理，此代理方法的簽名是（接收一個參數，不返回任何值）：

public delegate void Action<T> (T obj);

下面的代碼顯示了如何使用ForEach方法

Array.ForEach (new[] { 1, 2, 3 }, Console.WriteLine);

你可能會很好奇Array.ForEach是如何執行的，它就是這么執行的

public static void ForEach<T>(T[] array, Action<T> action) {
    if( array == null) {
        throw new ArgumentNullException("array");
    }

    if( action == null) {
        throw new ArgumentNullException("action");
    }
    Contract.EndContractBlock();

    for(int i = 0 ; i < array.Length; i++) {
        action(array[i]);
    }
}

在內部執行for循環，並調用Action代理。在上面的實例中，我們調用Console.WriteLine方法，所以可以在屏幕上輸出1，2，3。

 

獲取數組的長度和維度

Array提供了下列方法或屬性以獲取數組的長度和數組的維度：

public int GetLength (int dimension);
public long GetLongLength (int dimension);

public int Length { get; }
public long LongLength { get; }

public int GetLowerBound (int dimension);
public int GetUpperBound (int dimension);

public int Rank { get; }

GetLength和GetLongLength返回指定維度的長度（0表示一維數組），Length和LongLength返回數組中所有元素的總數（包含了所有維度）。

GetLowerBound和GetUpperBound對於多維數組非常有用。GetUpperBound返回的結果等於指定維度的GetLowerBound+指定維度的GetLength

 

搜索數組

Array類對外提供了一系列方法，以在一個維度中查找元素。比如：

• BinarySearch方法：在一個排序后的數組中快速找到指定元素；
• IndexOf/LastIndex方法：在未排序的數組中搜索指定元素；
• Find/FindLast/FindIndex/FindLastIndex/FindAll/Exists/TrueForAll方法：根據指定的Predicated<T>(代理)在未排序的數組中搜索一個或多個元素。

如果沒有找到指定的值，數組的這些搜索方法不會拋出異常。相反，搜索方法返回-1（假定數組的索引都是以0開始），或者返回generic類型的默認值（int返回0，string返回null）。

二進制搜索速度很快，但是它僅僅適用於排序后的數組，而且數組的元素是根據大小排序，而不是根據相等性排序。正因為如此，所以二進制搜索方法可以接收IComparer或IComparer<T>對象以對元素進行排序。傳入的IComparer或IComparer<T>對象必須和當前數組所使用的排序比較器一致。如果沒有提供比較器參數，那么數組會使用默認的排序算法。

IndexOf和LastIndexOf方法對數組進行簡單的遍歷，然后根據指定的值返回第一個（或最后一個）元素的位置。

以斷定為基礎（predicate-based）的搜索方法接受一個方法代理或lamdba表達式判斷元素是否滿足“匹配”。一個斷定（predicate）是一個簡單的代理，該代理接收一個對象並返回bool值：

public delegate bool Precicate<T>(T object);

下面的例子中，我們搜索字符數組中包含字母A的字符：

static void Main(string[] args)
{
    string[] names = { "Rodney", "Jack", "Jill" };
    string match = Array.Find(names, ContainsA);
    Console.WriteLine(match);

    Console.ReadLine();
}

static bool ContainsA(string name)
{
    return name.Contains("a");
}

上面的代碼可以簡化為：

static void Main(string[] args)
{
    string[] names = { "Rodney", "Jack", "Jill" };
    string match = Array.Find(names, delegate(string name) { return name.Contains("a"); });
    Console.WriteLine(match);

    Console.ReadLine();
}

如果使用lamdba表達式，那么代碼還可以更簡潔：

static void Main(string[] args)
{
    string[] names = { "Rodney", "Jack", "Jill" };
    string match = Array.Find(names, name=>name.Contains("a"));
    Console.WriteLine(match);

    Console.ReadLine();
}

FindAll方法則從數組中返回滿足斷言（predicate）的所有元素。實際上，該方法等同於Enumerable.Where方法，只不過數組的FindAll是從數組中返回匹配的元素，而Where方法從IEnumerable<T>中返回。

如果數組成員滿足指定的斷言（predicate），那么Exists方法返回True，該方法等同於Enumerable.Any方法。

所以數組的所有成員都滿足指定的斷言（predicate），那么TrueForAll方法返回True，該方法等同於Enumerable.All方法。

 

對數組排序

數組有下列自帶的排序方法：

public static void Sort<T>(T[] array);
public static void Sort(Array array);
public static void Sort(TKey, TValue)(TKey[] keys, TValue[] items);
public static void Sort(Array keys[], Array items);

上面的方法都有重載的版本，重載方法接受下面這些參數：

• int index，從指定索引位置開始排序
• int length，從指定索引位置開始，需要排序的元素的個數
• ICompare<T> comparer，用於排序決策的對象
• Comparison<T> comparison，用於排序決策的代理

下面的代碼演示了如何實現一個簡單的排序：

static void Main(string[] args)
{
    int[] numbers = { 3,2,1};
    Array.Sort(numbers);
    foreach (int number in numbers)
        Console.WriteLine(number);

    Console.ReadLine();
}

Sort方法還可以接收兩個兩個數組類型的參數，然后基於第一個數組的排序結果，對每個數組的元素進行排序。下面的例子中，數字數組和字符數組都按照數字數組的順序進行排序。

static void Main(string[] args)
{
    int[] numbers = { 3,2,1};
    string[] names = { "C", "B", "E" };
    Array.Sort(numbers, names);
    foreach (int number in numbers)
        Console.WriteLine(number); // 1, 2,3

    foreach (string name in names)
        Console.WriteLine(name); // E, B, C

    Console.ReadLine();
}

Array.Sort方法要求數組實現了IComparer接口。這就是說C#的大多數類型都可以排序。如果數組元素不能進行比較，或你希望重載默認的排序，那么你需要在調用Sort方法時，需提供自定義的Comparison。所以自定義排序算法有下面兩種實現方式：

1）通過一個幫助對象實現IComparer或IComparer<T>接口

public static void Sort(Array array, IComparer comparer)
public static void Sort<T>(T[] array, System.Collections.Generic.IComparer<T> comparer)

2）通過Comparison接口

public static void Sort<T>(T[] array, Comparison<T> comparison)

Comparison代理遵循IComparer<T>.CompareTo語法：

public delegate int Comparison<T> (T x, T y);

如果x的位置在y之前，那么返回-1；如果x在y之后，返回1，如果位置相同，那么返回0。

我們來看一下Array的Sort<T>(T[]array, Comparison<T> comparison)方法的源代碼：

public static void Sort<T>(T[] array, Comparison<T> comparison) {
    ......

    IComparer<T> comparer = new FunctorComparer<T>(comparison);
    Array.Sort(array, comparer);
}

由此，可內部，Comparison<T>轉換成IComparer<T>，因此在實際中，需要實現自定義排序時，如果需要考慮性能，那么推薦使用第一種方式。此外，我們分析Sort<T>(T[] array, System.Collections.Generic.IComparer<T> comparer)的源代碼，

public static void Sort<T>(T[] array, int index, int length, System.Collections.Generic.IComparer<T> comparer)
{
    ...

    if (length > 1)
    {
        if (comparer == null || comparer == Comparer<T>.Default)
        {
            if (TrySZSort(array, null, index, index + length - 1))
            {
                return;
            }
        }

        ArraySortHelper<T>.Default.Sort(array, index, length, comparer);
    }
}

我們可以看到，首先嘗試調用調用非托管代碼的Sort方法，如果成功排序，直接返回。否則調用非托管代碼（C#的ArraySortHelper）的Sort方法進行排序：

public void Sort(T[] keys, int index, int length, IComparer<T> comparer)
{
    …
    try
    {
        if (comparer == null)
        {
            comparer = Comparer<T>.Default;
        }

        if (BinaryCompatibility.TargetsAtLeast_Desktop_V4_5)
        {
            IntrospectiveSort(keys, index, length, comparer);
        }
        else
        {
            DepthLimitedQuickSort(keys, index, length + index - 1, comparer, IntrospectiveSortUtilities.QuickSortDepthThreshold);
        }
    }
    catch (IndexOutOfRangeException)
    {
        IntrospectiveSortUtilities.ThrowOrIgnoreBadComparer(comparer);
    }
    catch (Exception e)
    {
        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"), e);
    }
}

如果有興趣，可以繼續分析IntrospectiveSort方法和DepthLimitedQuickSort，不過MSDN已經給出了總結，

意識是說，排序算法有三種：

• 如果分區大小小於16，那么使用插入排序算法
• 如果分區的大小超過2*Log^N，N是數組的范圍，那么使用堆排序
• 其他情況，則使用快排

 

反轉數組的元素

使用下面的方法，可以反轉數組的所有元素或部分元素

public static void Reverse (Array array);
public static void Reverse (Array array, int index, int length);

如果你在乎性能，那么請不要直接調用Array的Reverse方法，而是應該創建一個自定義的RerverseComparer。比如下面的例子中，調用Array.Reverse和CustomReverse在我的電腦上兩者的性能高差距為20%左右

class Program
{
    static void Main(string[] args)
    {
        int seeds = 100000;

        Staff[] staffs = new Staff[seeds];
        Random r = new Random();
        for (int i = 0; i < seeds; i++)
            staffs[i] = new Staff { StaffNo = r.Next(1, seeds).ToString() };


        ArrayReverse(staffs); 
        CustomReverse(staffs); 

        Console.ReadLine();
    }

    static void ArrayReverse(Staff[] staffs)
    {
        DateTime t1 = DateTime.Now;
        Array.Sort(staffs);
        Array.Reverse(staffs);
        DateTime t2 = DateTime.Now;
        Console.WriteLine("Array Reverse: " + (t2 - t1).Milliseconds + "ms");
    }

    static void CustomReverse(Staff[] staffs)
    {
        DateTime t1 = DateTime.Now;
        Array.Sort(staffs, new StaffComparer());
        DateTime t2 = DateTime.Now;
        Console.WriteLine("Custom Reverse: " + (t2 - t1).Milliseconds + "ms");
    }

    internal class Staff : IComparable
    {
        public string StaffNo { get; set; }
        public string Name { get; set; }

        public int CompareTo(object obj)
        {
            Staff x = obj as Staff;

            return this.StaffNo.CompareTo(x.StaffNo);
        }
    }

    internal class StaffComparer : IComparer<Staff>
    {
        public int Compare(Staff x, Staff y)
        {
            return y.StaffNo.CompareTo(x.StaffNo);
        }
    }
}

執行結果：

 

復制數組

Array提供了四個方法以實現淺拷貝：Clone，CopyTo，Copy和ConstrainedCopy。前兩個方法是實例方法，后面兩個是靜態方法。

Clone方法返回一個全新的（淺拷貝）數組 。CopyTo和Copy方法復制數組的連續子集。復制一個多維矩形數組需要你的多維索引映射到一個線性索引。比如，一個3×3的數組position，那么postion[1,1]對應的線性索引為1*3+1=4。原數組和目標數組的范圍可以交換，不會帶來任何問題。

ConstrainedCopy執行原子操作，如果所要求的元素不能全部成功地復制，那么操作回滾。

Array還提供AsReadOnly方法，它返回一個包裝器，以防止數組元素的值被更改。

最后，Clone方法是由外部的非托管代碼實現

protected extern Object MemberwiseClone()

同樣地，Copy，CopyTo, ConstraintedCopy也都是調用外部實現

internal static extern void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length, bool reliable);

 

轉換數組和縮減數組大小

Array.ConvertAll創建並返回一個類型為TOutput的新數組，調用Converter代理以復制元素到新的數組中。Converter的定義如下：

public delegate TOutput Converter<TInput,TOutput>(TInput input)

下面的代碼展示了如果把一個浮點數數組轉換成int數組

float[] reals = { 1.3f, 1.5f, 1.8f };

int[] wholes = Array.ConvertAll(reals, f => Convert.ToInt32(f));

foreach (int a in wholes)
    Console.WriteLine(a);  //->1,2,2

Resize方法創建一個新數組，然后復制元素到新數組，然后返回新數組；原數組不發生改變。