C#集合--数组

时间 2019-11-13

标签 c# 集合数组栏目 C# 繁體版

原文原文链接

Array类是全部一维和多维数组的隐式基类，同时也是实现标准集合接口的最基本的类型。Array类实现了类型统一，所以它为全部数组提供了一组通用的方法，不论这些数组元素的类型，这些通用的方法均适用。算法

正由于数组如此重要，因此C#为声明数组和初始化数组提供了明确的语法。在使用C#语法声明一个数组时，CLR隐式地构建Array类--合成一个伪类型以匹配数组的维数和数组元素的类型。并且这个伪类型实现了generic集合接口，好比IList<string>接口。数组

CLR在建立数组类型实例时会作特殊处理--在内存中为数组分配连续的空间。这就使得索引数组很是高效，但这却阻止了对数组的修改或调正数组大小。dom

Array类实现了IList<T>接口和IList接口。Array类显示地实现了IList<T>接口，这是为了保证接口的完整性。可是在固定长度集合好比数组上调用IList<T>接口的Add或Remove方法时，会抛出异常（由于数组实例一旦声明以后，就不能更改数组的长度）。Array类提供了一个静态的Resize方法，使用这个方法建立一个新的数组实例，而后复制当前数组的元素到新的实例。此外，在程序中，当在任何地方引用一个数组都会执行最原始版本的数组实例。所以若是但愿集合大小能够调整，那么你最好使用List<T>类。post

数组元素能够是值类型也能够是引用类型。值类型数组元素直接存在数组中，好比包含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");

对应的内存分配变化以下面几张图所示：ui

执行完int[] numbers=new int[3]以后，在内存中分配了8×3=24个字节，每一个字节都为0。this

执行完numbers[0]=1以后，数组声明后的第一个8字节变为00 00 00 01。spa

一样地，执行完numbers[1]=7以后，第二段8个字节变为00 00 00 07。设计

对应引用类型的数组，咱们用一张图来讲明内存分配：3d

看起来分复杂，其实内存分配示意图以下

经过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方法建立一个新数组，而后复制元素到新数组，而后返回新数组；原数组不发生改变。