精华内容
下载资源
问答
  • c# 数组

    2014-05-29 14:08:14
    c# 数组
  • C#数组

    2019-10-15 19:36:48
    C#数组(Array) 数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合,通常认为数组是一个同一类型变量的集合。 声明数组变量并不是声明 number0、number1、...、number99 一个个单独的...

    C# 数组(Array)

    数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合,通常认为数组是一个同一类型变量的集合。

    声明数组变量并不是声明 number0、number1、...、number99 一个个单独的变量,而是声明一个就像 numbers 这样的变量,然后使用 numbers[0]、numbers[1]、...、numbers[99] 来表示一个个单独的变量。数组中某个指定的元素是通过索引来访问的。

    所有的数组都是由连续的内存位置组成的。最低的地址对应第一个元素,最高的地址对应最后一个元素。

    C# 中的数组

    声明数组

    在 C# 中声明一个数组,您可以使用下面的语法:

    datatype[] arrayName;

    其中,

    • datatype 用于指定被存储在数组中的元素的类型。
    • [ ] 指定数组的秩(维度)。秩指定数组的大小。
    • arrayName 指定数组的名称。

    例如:

    double[] balance;

    初始化数组

    声明一个数组不会在内存中初始化数组。当初始化数组变量时,您可以赋值给数组。

    数组是一个引用类型,所以您需要使用 new 关键字来创建数组的实例。

    例如:

    double[] balance = new double[10];

    赋值给数组

    您可以通过使用索引号赋值给一个单独的数组元素,比如:

    double[] balance = new double[10];
    balance[0] = 4500.0;

    您可以在声明数组的同时给数组赋值,比如:

    double[] balance = { 2340.0, 4523.69, 3421.0};

    您也可以创建并初始化一个数组,比如:

    int [] marks = new int[5]  { 99,  98, 92, 97, 95};

    在上述情况下,你也可以省略数组的大小,比如:

    int [] marks = new int[]  { 99,  98, 92, 97, 95};

    您也可以赋值一个数组变量到另一个目标数组变量中。在这种情况下,目标和源会指向相同的内存位置:

    int [] marks = new int[]  { 99,  98, 92, 97, 95};
    int[] score = marks;

    当您创建一个数组时,C# 编译器会根据数组类型隐式初始化每个数组元素为一个默认值。例如,int 数组的所有元素都会被初始化为 0。

    访问数组元素

    元素是通过带索引的数组名称来访问的。这是通过把元素的索引放置在数组名称后的方括号中来实现的。例如:

    double salary = balance[9];

    下面是一个实例,使用上面提到的三个概念,即声明、赋值、访问数组:

    实例

    using System;
    namespace ArrayApplication
    {
       class MyArray
       {
          static void Main(string[] args)
          {
             int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */
             int i,j;
    
    
             /* 初始化数组 n 中的元素 */         
             for ( i = 0; i < 10; i++ )
             {
                n[ i ] = i + 100;
             }
    
             /* 输出每个数组元素的值 */
             for (j = 0; j < 10; j++ )
             {
                Console.WriteLine("Element[{0}] = {1}", j, n[j]);
             }
             Console.ReadKey();
          }
       }
    }

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

    Element[0] = 100
    Element[1] = 101
    Element[2] = 102
    Element[3] = 103
    Element[4] = 104
    Element[5] = 105
    Element[6] = 106
    Element[7] = 107
    Element[8] = 108
    Element[9] = 109

    使用 foreach 循环

    在前面的实例中,我们使用一个 for 循环来访问每个数组元素。您也可以使用一个 foreach 语句来遍历数组。

    实例

    using System;
    
    namespace ArrayApplication
    {
       class MyArray
       {
          static void Main(string[] args)
          {
             int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */
    
    
             /* 初始化数组 n 中的元素 */         
             for ( int i = 0; i < 10; i++ )
             {
                n[i] = i + 100;
             }
    
             /* 输出每个数组元素的值 */
             foreach (int j in n )
             {
                int i = j-100;
                Console.WriteLine("Element[{0}] = {1}", i, j);
             }
             Console.ReadKey();
          }
       }
    }

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

    Element[0] = 100
    Element[1] = 101
    Element[2] = 102
    Element[3] = 103
    Element[4] = 104
    Element[5] = 105
    Element[6] = 106
    Element[7] = 107
    Element[8] = 108
    Element[9] = 109

    C# 数组细节

    在 C# 中,数组是非常重要的,且需要了解更多的细节。下面列出了 C# 程序员必须清楚的一些与数组相关的重要概念:

    概念 描述
    多维数组 C# 支持多维数组。多维数组最简单的形式是二维数组。
    交错数组 C# 支持交错数组,即数组的数组。
    传递数组给函数 您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。
    参数数组 这通常用于传递未知数量的参数给函数。
    Array 类 在 System 命名空间中定义,是所有数组的基类,并提供了各种用于数组的属性和方法。
    展开全文
  • C# 数组

    2016-10-01 17:29:00
    C# 数组 二维数组由若干个一维数组组成。 在C++中,组成二维数组的一维数组长度必须相等。在C#中却可以不相等。 C#二维数组有两种: 1,普通二维数组: int [,] arr2d = new int[3,2]; int[,] scroes...

    C# 数组

    二维数组由若干个一维数组组成。

    在C++中,组成二维数组的一维数组长度必须相等。在C#中却可以不相等。

    C#二维数组有两种:

    1,普通二维数组:

    int [,] arr2d = new int[3,2];
    int[,] scroes2d2 = new int[3, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 } };

    2,数组的数组:又称锯齿数组,交错数组

    int[][] varr = new int[3][] //不能写成int[][] varr = new int[3][2]
    int[][] varr2 = new int[3][] { new int[1] { 1 }, new int[3] { 1, 2, 3 }, new int[2] { 1, 2 } };

    测试代码:

    class Program
        {
            static void Main(string[] args)
            {
                int[] scroes = new int[5];
                int[,] scroes2d = new int[3,2];
                Console.WriteLine("scroes2d.length:{0}", scroes2d.Length); //6
                for(int i=0; i<3; ++i)
                {
                    for(int j=0; j<2; ++j)
                    {
                        scroes2d[i, j] = i * 2 + j;
                    }
                }
    
                int[][] varr = new int[3][];
                Console.WriteLine("varr.length:{0}", varr.Length); //3
                for(int i=0; i<varr.Length; ++i)
                {
                    varr[i] = new int[i + 1];
                    for(int j=0; j<varr[i].Length; ++j)
                    {
                        varr[i][j] = j;
                    }
                }
                foreach(var arr in varr)
                {
                    foreach(var n in arr)
                    Console.Write(n);
                    Console.WriteLine();
                }
                Console.ReadKey();
            }
    
        }

     

    • 附:参数数组

    有时,当声明一个方法时,您不能确定要传递给函数作为参数的参数数目。C# 参数数组解决了这个问题,参数数组通常用于传递未知数量的参数给函数。

    在使用数组作为形参时,C# 提供了 params 关键字,使调用数组为形参的方法时,既可以传递数组实参,也可以只传递一组数组。params 的使用格式为:

    public 返回类型 方法名称( params 类型名称[] 数组名称 )

        class CTest
        {
            public void func(params int[] arr)
            {
                foreach(var n in arr)
                {
                    Console.Write(n + ",");
                }
            }
        }
        class Program
        {
            static void Main(string[] args)
            {

                  CTest ot = new CTest();
                  ot.func(1,2,3,4,5,6,7,8,9,0);
                  ot.func(new int[] { 1, 2, 3, 4 });

         }
            }

     

    posted on 2016-10-01 17:29 时空观察者9号 阅读(...) 评论(...) 编辑 收藏

    展开全文
  • c#数组

    2011-12-19 13:29:48
    C# 数组从零开始建立索引,即数组索引从零开始。C#数组的工作方式与在大多数其他流行语言中的工作方式类似。但还有一些差异应引起注意。 声明数组时,方括号 ([]) 必须跟在类型后面,而不是标识符后面。在 C# ...
     数组概述
    

    C# 数组从零开始建立索引,即数组索引从零开始。C# 中数组的工作方式与在大多数其他流行语言中的工作方式类似。但还有一些差异应引起注意。

    声明数组时,方括号 ([]) 必须跟在类型后面,而不是标识符后面。在 C# 中,将方括号放在标识符后是不合法的语法。

    int[] table; // not int table[]; 

    另一细节是,数组的大小不是其类型的一部分,而在 C 语言中它却是数组类型的一部分。这使您可以声明一个数组并向它分配 int 对象的任意数组,而不管数组长度如何。

    int[] numbers; // declare numbers as an int array of any size

    numbers = new int[10];  // numbers is a 10-element array

    numbers = new int[20];  // now it's a 20-element array

     声明数组

    C# 支持一维数组、多维数组(矩形数组)和数组的数组(交错的数组)。下面的示例展示如何声明不同类型的数组:

    一维数组:

    int[] numbers;

    多维数组:

    string[,] names;

    数组的数组(交错的):

    byte[][] scores;

    声明数组(如上所示)并不实际创建它们。 C# 中,数组是对象(本教程稍后讨论),必须进行实例化。下面的示例展示如何创建数组:

    一维数组:

    int[] numbers = new int[5];

    多维数组:

    string[,] names = new string[5,4];

    数组的数组(交错的):

    byte[][] scores = new byte[5][];
    for (int x = 0; x < scores.Length; x++) 
    {
       scores[x] = new byte[4];
    }

    还可以有更大的数组。例如,可以有三维的矩形数组:

    int[,,] buttons = new int[4,5,3];

    甚至可以将矩形数组和交错数组混合使用。例如,下面的代码声明了类型为 int 的二维数组的三维数组的一维数组。

    int[][,,][,] numbers;
     初始化数组

    C# 通过将初始值括在大括号 ({}) 内为在声明时初始化数组提供了简单而直接了当的方法。下面的示例展示初始化不同类型的数组的各种方法。

    注意   如果在声明时没有初始化数组,则数组成员将自动初始化为该数组类型的默认初始值。另外,如果将数组声明为某类型的字段,则当实例化该类型时它将被设置为默认值 null

     一维数组

    int[] numbers = new int[5] {1, 2, 3, 4, 5};
    string[] names = new string[3] {"Matt", "Joanne", "Robert"};

    可省略数组的大小,如下所示:

    int[] numbers = new int[] {1, 2, 3, 4, 5};
    string[] names = new string[] {"Matt", "Joanne", "Robert"};

    如果提供了初始值设定项,则还可以省略 new 运算符,如下所示:

    int[] numbers = {1, 2, 3, 4, 5};
    string[] names = {"Matt", "Joanne", "Robert"};

    多维数组

    int[,] numbers = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} };
    string[,] siblings = new string[2, 2] { {"Mike","Amy"}, {"Mary","Albert"} };

    可省略数组的大小,如下所示:

    int[,] numbers = new int[,] { {1, 2}, {3, 4}, {5, 6} };
    string[,] siblings = new string[,] { {"Mike","Amy"}, {"Mary","Albert"} };

    如果提供了初始值设定项,则还可以省略 new 运算符,如下所示:

    int[,] numbers = { {1, 2}, {3, 4}, {5, 6} };
    string[,] siblings = { {"Mike", "Amy"}, {"Mary", "Albert"} };

    交错的数组(数组的数组

    可以像下例所示那样初始化交错的数组:

    int[][] numbers = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

    可省略第一个数组的大小,如下所示:

    int[][] numbers = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

    -或-

    int[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

    请注意,对于交错数组的元素没有初始化语法。

    访问数组成员

    访问数组成员可以直接进行,类似于在 C/C++ 中访问数组成员。例如,下面的代码创建一个名为 numbers 的数组,然后向该数组的第五个元素赋以 5

    int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    numbers[4] = 5;

    下面的代码声明一个多维数组,并向位于 [1, 1] 的成员赋以 5

    int[,] numbers = { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} };
    numbers[1, 1] = 5;

    下面声明一个一维交错数组,它包含两个元素。第一个元素是两个整数的数组,第二个元素是三个整数的数组:

    int[][] numbers = new int[][] { new int[] {1, 2}, new int[] {3, 4, 5}
    };

    下面的语句向第一个数组的第一个元素赋以 58,向第二个数组的第二个元素赋以 667

    numbers[0][0] = 58;
    numbers[1][1] = 667;
    数组是对象

    C# 中,数组实际上是对象System.Array 是所有数组类型的抽象基类型。可以使用 System.Array 具有的属性以及其他类成员。这种用法的一个示例是使用长度”(Length) 属性获取数组的长度。下面的代码将 numbers 数组的长度(为 5)赋给名为 LengthOfNumbers 的变量:

    int[] numbers = {1, 2, 3, 4, 5};
    int LengthOfNumbers = numbers.Length;

    System.Array 类提供许多有用的其他方法/属性,如用于排序、搜索和复制数组的方法。

    对数组使用 foreach

    C# 还提供 foreach 语句。该语句提供一种简单、明了的方法来循环访问数组的元素。例如,下面的代码创建一个名为 numbers 的数组,并用 foreach 语句循环访问该数组:

    int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0};
    foreach (int i in numbers)
    {
       System.Console.WriteLine(i);
    }

    由于有了多维数组,可以使用相同方法来循环访问元素,例如:

    int[,] numbers = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}};
    foreach(int i in numbers)
    {
       Console.Write("{0} ", i);
    }

    该示例的输出为:

    9 99 3 33 5 55

    不过,由于有了多维数组,使用嵌套 for 循环将使您可以更好地控制数组元素。

    展开全文

空空如也

空空如也

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

c#数组

c# 订阅