现在位置: 首页 > C# 教程 > 正文

C# Array 类

C# 数组 C# 数组

Array 类是 C# 中所有数组的基类，它是在 System 命名空间中定义。Array 类提供了各种用于数组的属性和方法。

C# 中的 Array 类是所有数组的基类，位于 System 命名空间下。

数组是一种用于存储固定大小、同一类型元素的集合。理解 Array 类的特性和方法对于高效编写 C# 程序非常重要。

以下是对 C# Array 类的详细介绍，包括其特性、常用方法、属性和使用示例。

特性

  • 类型安全：数组只能存储指定类型的元素，类型在声明时确定。
  • 固定长度：数组的长度在创建后不可更改。
  • 索引访问：数组中的元素通过索引访问，索引从 0 开始。
  • 多维支持：C# 支持一维、多维和交错数组（数组的数组）。

Array 类的属性

下表列出了 Array 类中一些最常用的属性：

属性名说明示例代码输出
Length获取数组中元素的总个数。int[] arr = {1, 2, 3};
int length = arr.Length;		3
Rank获取数组的维数（即数组的维度）。int[,] matrix = new int[2, 3];
int rank = matrix.Rank;		2
IsFixedSize判断数组的大小是否固定。int[] arr = {1, 2, 3};
bool fixedSize = arr.IsFixedSize;		true
IsReadOnly判断数组是否为只读。int[] arr = {1, 2, 3};
bool readOnly = arr.IsReadOnly;		false
IsSynchronized判断数组是否线程安全。int[] arr = {1, 2, 3};
bool sync = arr.IsSynchronized;		false
SyncRoot获取用于同步数组访问的对象，通常用于多线程操作。int[] arr = {1, 2, 3};
object syncRoot = arr.SyncRoot;		syncRoot

如需了解 Array 类的完整的属性列表，请参阅微软的 C# 文档。

Array 类的方法

下表列出了 Array 类中一些最常用的方法：

序号方法 & 描述
1Clear
根据元素的类型，设置数组中某个范围的元素为零、为 false 或者为 null。
2Copy(Array, Array, Int32)
从数组的第一个元素开始复制某个范围的元素到另一个数组的第一个元素位置。长度由一个 32 位整数指定。
3CopyTo(Array, Int32)
从当前的一维数组中复制所有的元素到一个指定的一维数组的指定索引位置。索引由一个 32 位整数指定。
4GetLength
获取一个 32 位整数，该值表示指定维度的数组中的元素总数。
5GetLongLength
获取一个 64 位整数，该值表示指定维度的数组中的元素总数。
6GetLowerBound
获取数组中指定维度的下界。
7GetType
获取当前实例的类型。从对象（Object）继承。
8GetUpperBound
获取数组中指定维度的上界。
9GetValue(Int32)
获取一维数组中指定位置的值。索引由一个 32 位整数指定。
10IndexOf(Array, Object)
搜索指定的对象，返回整个一维数组中第一次出现的索引。
11Reverse(Array)
逆转整个一维数组中元素的顺序。
12SetValue(Object, Int32)
给一维数组中指定位置的元素设置值。索引由一个 32 位整数指定。
13Sort(Array)
使用数组的每个元素的 IComparable 实现来排序整个一维数组中的元素。
14ToString
返回一个表示当前对象的字符串。从对象（Object）继承。

更多方法参考说明

  1. AsReadOnly<T>(T[])

    • 返回指定数组的只读包装。

  2. BinarySearch

    • BinarySearch(Array, Int32, Int32, Object, IComparer)：在排序的数组中搜索值，使用指定的 IComparer 接口。
    • BinarySearch(Array, Int32, Int32, Object)：在排序的数组中搜索值，使用 IComparable 接口。
    • BinarySearch(Array, Object, IComparer)：搜索排序的数组，使用指定的 IComparer 接口。
    • BinarySearch(Array, Object)：搜索排序的数组，使用 IComparable 接口。
    • BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)：在泛型数组范围内搜索值，使用指定的 IComparer<T> 接口。
    • BinarySearch<T>(T[], Int32, Int32, T)：在泛型数组范围内搜索值，使用 IComparable<T> 接口。
    • BinarySearch<T>(T[], T, IComparer<T>)：搜索排序的泛型数组，使用指定的 IComparer<T> 接口。
    • BinarySearch<T>(T[], T)：搜索排序的泛型数组，使用 IComparable<T> 接口。

  3. Clear

    • Clear(Array, Int32, Int32)：将数组中指定范围内的元素设置为默认值。
    • Clear(Array)：清空数组内容。

  4. Clone

    • 创建数组的浅拷贝。

  5. ConstrainedCopy

    • 从源数组复制指定范围的元素到目标数组，保证在整个复制操作成功后进行更改。

  6. ConvertAll<TInput, TOutput>(TInput[], Converter<TInput, TOutput>)

    • 将一种类型的数组转换为另一种类型的数组。

  7. Copy

    • Copy(Array, Array, Int32)：将数组元素复制到目标数组中，长度为32位整型。
    • Copy(Array, Array, Int64)：将数组元素复制到目标数组中，长度为64位整型。
    • Copy(Array, Int32, Array, Int32, Int32)：从源数组复制指定范围的元素到目标数组。
    • Copy(Array, Int64, Array, Int64, Int64)：从源数组复制指定范围的元素到目标数组。
    • CopyTo(Array, Int32)：将当前数组复制到目标数组中，指定从目标数组的哪个索引位置开始。
    • CopyTo(Array, Int64)：同上，索引为64位整型。

  8. CreateInstance

    • CreateInstance(Type, Int32)：创建指定类型和长度的一维数组。
    • CreateInstance(Type, Int32, Int32)：创建二维数组。
    • CreateInstance(Type, Int32, Int32, Int32)：创建三维数组。
    • CreateInstance(Type, Int32[])：创建多维数组，使用指定的维度。
    • CreateInstance(Type, Int64[])：创建多维数组，使用64位整型维度。

  9. Empty<T>

    • 返回一个空的数组实例。

  10. Exists<T>(T[], Predicate<T>)

    • 确定数组是否包含符合条件的元素。

  11. Fill<T>(T[], T, Int32, Int32)

    • 填充数组中从指定索引范围的所有元素为给定值。
    • Fill<T>(T[], T)：填充整个数组的元素为给定值。

  12. Find

    • Find<T>(T[], Predicate<T>)：搜索符合条件的第一个元素并返回。
    • FindAll<T>(T[], Predicate<T>)：返回符合条件的所有元素。
    • FindIndex<T>(T[], Int32, Int32, Predicate<T>)：在数组的指定范围内返回第一个符合条件的元素的索引。
    • FindIndex<T>(T[], Int32, Predicate<T>)：在指定索引后返回第一个符合条件的元素索引。
    • FindIndex<T>(T[], Predicate<T>)：返回第一个符合条件的元素的索引。
    • FindLast<T>(T[], Predicate<T>)：返回符合条件的最后一个元素。
    • FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)：在数组的指定范围内，返回符合条件的最后一个元素的索引。
    • FindLastIndex<T>(T[], Predicate<T>)：返回符合条件的最后一个元素的索引。

  13. ForEach<T>(T[], Action<T>)

    • 对数组的每个元素执行指定的操作。

  14. GetEnumerator()

    • 获取数组的枚举器。

  15. GetLength

    • GetLength(Int32)：获取数组指定维度的元素个数。

  16. GetLongLength(Int32)

    • 获取64位整型的数组长度。

  17. GetLowerBound(Int32)

    • 获取数组指定维度的第一个元素的索引。

  18. GetUpperBound(Int32)

    • 获取数组指定维度的最后一个元素的索引。

  19. GetValue

    • GetValue(Int32)：获取一维数组指定索引的值。
    • GetValue(Int32, Int32)：获取二维数组指定索引的值。
    • GetValue(Int32, Int32, Int32)：获取三维数组指定索引的值。
    • GetValue(Int32[])：获取多维数组的值。

  20. IndexOf

    • IndexOf(Array, Object)：返回指定对象第一次出现的索引。
    • IndexOf(Array, Object, Int32)：返回指定对象在数组中特定范围内第一次出现的索引。
    • IndexOf(Array, Object, Int32, Int32)：返回指定对象在数组中指定范围内第一次出现的索引。

  21. LastIndexOf

    • 类似于 IndexOf，但从数组末尾开始搜索。

  22. Resize<T>(T[], Int32)

    • 改变一维数组的大小。

  23. Reverse

    • Reverse(Array)：反转数组中的元素顺序。
    • Reverse<T>(T[])：反转泛型数组中的元素顺序。

  24. SetValue

    • SetValue(Object, Int32)：设置数组指定索引的值。
    • SetValue(Object, Int32, Int32)：设置二维数组指定位置的值。

  25. Sort

    • Sort(Array)：对数组进行排序。
    • Sort<T>(T[], IComparer<T>)：对泛型数组进行排序。

  26. TrueForAll<T>(T[], Predicate<T>)

    • 确定数组中是否所有元素都符合条件。

如需了解 Array 类的完整的方法列表，请参阅微软的 C# 文档。

实例

下面的程序演示了 Array 类的一些方法的用法：

实例

using System;
namespace ArrayApplication
{
    class MyArray
    {
       
        static void Main(string[] args)
        {
            int[] list = { 34, 72, 13, 44, 25, 30, 10 };

            Console.Write("原始数组： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
           
            // 逆转数组
            Array.Reverse(list);
            Console.Write("逆转数组： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
           
            // 排序数组
            Array.Sort(list);
            Console.Write("排序数组： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();

           Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

原始数组： 34 72 13 44 25 30 10
逆转数组： 10 30 25 44 13 72 34
排序数组： 10 13 25 30 34 44 72

常用方法举例

1. Array.Clear(Array, int index, int length)

将数组中指定范围的元素设置为其类型的默认值。

int[] arr = {1, 2, 3, 4, 5};
Array.Clear(arr, 1, 2); // arr = {1, 0, 0, 4, 5}

2. Array.Copy(Array sourceArray, Array destinationArray, int length)

从源数组复制元素到目标数组。

int[] source = {1, 2, 3};
int[] destination = new int[3];
Array.Copy(source, destination, 3); // destination = {1, 2, 3}

3. Array.Clone()

创建数组的浅表副本。

int[] arr = {1, 2, 3};
int[] clonedArr = (int[])arr.Clone();

4. Array.IndexOf(Array array, object value)

返回指定元素在一维数组中第一次出现的索引。

int[] arr = {1, 2, 3, 2};
int index = Array.IndexOf(arr, 2); // index = 1

5. Array.LastIndexOf(Array array, object value)

返回指定元素在一维数组中最后一次出现的索引。

int[] arr = {1, 2, 3, 2};
int lastIndex = Array.LastIndexOf(arr, 2); // lastIndex = 3

6. Array.Reverse(Array array)

反转一维数组中元素的顺序。

int[] arr = {1, 2, 3};
Array.Reverse(arr); // arr = {3, 2, 1}

7. Array.Sort(Array array)

对一维数组的元素进行升序排序。

int[] arr = {3, 1, 2};
Array.Sort(arr); // arr = {1, 2, 3}

8. Array.BinarySearch(Array array, object value)

在排序的一维数组中搜索元素，返回其索引。

int[] arr = {1, 2, 3, 4, 5};
int index = Array.BinarySearch(arr, 3); // index = 2

注意：使用 BinarySearch 前，数组必须已排序。

9. Array.Resize(ref T[] array, int newSize)

调整一维数组的大小。

int[] arr = {1, 2, 3};
Array.Resize(ref arr, 5); // arr = {1, 2, 3, 0, 0}

10. Array.Exists<T>(T[] array, Predicate match)

确定数组中是否存在符合条件的元素。

int[] arr = {1, 2, 3};
bool exists = Array.Exists(arr, x => x == 2); // exists = true

11. Array.Find<T>(T[] array, Predicate match)

查找数组中第一个符合条件的元素。

int[] arr = {1, 2, 3, 4};
int result = Array.Find(arr, x => x > 2); // result = 3

12. Array.FindAll<T>(T[] array, Predicate match)

查找数组中所有符合条件的元素。

int[] arr = {1, 2, 3, 4};
int[] results = Array.FindAll(arr, x => x > 2); // results = {3, 4}

13. Array.FindIndex<T>(T[] array, Predicate match)

返回第一个符合条件的元素的索引。

int[] arr = {1, 2, 3, 4};
int index = Array.FindIndex(arr, x => x > 2); // index = 2

14. Array.FindLast<T>(T[] array, Predicate match)

查找最后一个符合条件的元素。

int[] arr = {1, 2, 3, 4};
int result = Array.FindLast(arr, x => x > 2); // result = 4

15. Array.FindLastIndex<T>(T[] array, Predicate match)

返回最后一个符合条件的元素的索引。

int[] arr = {1, 2, 3, 4};
int index = Array.FindLastIndex(arr, x => x > 2); // index = 3

16. Array.TrueForAll<T>(T[] array, Predicate match)

确定数组中的所有元素是否都满足条件。

int[] arr = {1, 2, 3};
bool allPositive = Array.TrueForAll(arr, x => x > 0); // allPositive = true

17. Array.ForEach<T>(T[] array, Action action)

对数组的每个元素执行指定的操作。

int[] arr = {1, 2, 3};
Array.ForEach(arr, x => Console.WriteLine(x)); // 输出 1 2 3

18. Array.ConstrainedCopy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)

将一个数组的部分元素复制到另一个数组，并确保在复制失败时不会导致数据损坏。 
int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[5];
Array.ConstrainedCopy(source, 0, destination, 0, 5);

19. Array.Fill<T>(T[] array, T value)

将数组的所有元素设置为指定的值。

int[] arr = new int[5];
Array.Fill(arr, 10); // arr = {10, 10, 10, 10, 10}

20. Array.AsReadOnly<T>(T[] array)

返回数组的只读包装。

int[] arr = {1, 2, 3};
var readOnlyArr = Array.AsReadOnly(arr);
// readOnlyArr[0] = 5; // 编译错误，集合是只读的

实例

using System;

class Program
{
    static void Main()
    {
        // 创建并初始化数组
        int[] numbers = {5, 2, 8, 1, 3};

        // 排序数组
        Array.Sort(numbers); // numbers = {1, 2, 3, 5, 8}

        // 查找元素
        int index = Array.BinarySearch(numbers, 5); // index = 3

        // 反转数组
        Array.Reverse(numbers); // numbers = {8, 5, 3, 2, 1}

        // 检查是否存在大于 6 的元素
        bool exists = Array.Exists(numbers, x => x > 6); // exists = true

        // 将数组元素乘以 2
        Array.ForEach(numbers, x => Console.WriteLine(x * 2));

        // 调整数组大小
        Array.Resize(ref numbers, 7); // numbers = {8, 5, 3, 2, 1, 0, 0}

        // 填充新元素
        Array.Fill(numbers, 10, 5, 2); // 从索引 5 开始的 2 个元素设置为 10
        // numbers = {8, 5, 3, 2, 1, 10, 10}
    }
}

C# 数组 C# 数组

返回顶部
© 2024 菜鸟教程
备案号：闽ICP备15012807号-1

∧