黑马程序员_数组

------- Windows Phone 7手机开发.Net培训、期待与您交流! ------- 

数组

数组是C#语言最常用的数据结构之一。在编程中,有时需要保存一组相同类型的数字。这时候使用数组,方便命名和调用。数组是一组类型相同的变量的集合,可以通过公共的名称来访问其中的变量。

使用数组

数组是一个有序的数据集合,通过数组统一访问或操作这些元素。数组中的每一个元素的数据类型都相同。元素的数据类型被称为元素类型,它可以为任何类型,甚至可以为数组。在内存中,数组占用一块连续的内存,元素按顺序存放在一起,数组中每一个单独的元素并没有自己的名字,但是可以通过其位置来进行访问或修改。

注意:在C#语言中,数组的下标从0开始,即s[0]表示s数组的第一个元素。

数组的基准—维度数

在直线、平面和空间中,称描述一个点所需要值的数量为“维度数”。数组也一样,当要描述数组中的一个元素时,

如果只需要一个值(数组的下标),那么该数组的维度数为1;

如果需要两个值,那么该数组的维度数为2;依次类推。

根据数组的维度数不同,可以把数组分为以下3种类型。

一维数组:维度数为1的数组。

二维数组:维度数为2的数组。

多维数组:维度数大于2的数组。

声明数组

同类、结构一样,如果需要某一个数组,则必须首先声明该数组。

声明一维数组的语法如下。

type[] arrayName;其中,type表示数组元素的类型,如int、double、string、object等;arrayName表示数组的名称。

下面声明一个数组。它的元素类型为int,名称为arr。

int[] arr;                       //声明一个int型的数组arr

下面声明一个数组。它的元素类型为string,名称为arr2。

string[] arr2;                //声明一个string型的数组arr2

实例化数组

数组需要分配相应的内存后才能正常存取数据。实例化数组就是为数组分配相应的内存。需要注意的是,声明一个数组,并不为该数组分配相应的内存。

下面实例化数组arr,并为该数组分配相应的内存。由于arr数组的长度为10,因此该数组分配10×4字节的内存(该数组的元素类型为int,每一个int类型的值占4个字节)。

arr = new int[10];            //实例化int型的数组arr

初始化数组

变量可以初始化,数组也可以在定义的同时为各数组元素赋初值。初始化数组就是初始化数组中每一个元素的值,即为数组中的每一个元素进行赋值。数组被实例化之后,每个元素都为其元素类型的默认值。一般情况下,只有初始化数组之后,该数组才具有实际运算的意义。

注意:如果数组没有被初始化,那么该数组的每一个元素的值为其元素类型的默认值。如arr数组的默认值为0。

初始化数组有多种方法,主要包括以下4种。

1.直接赋值

直接赋值是将一组值直接赋给数组,这组值被包括在大括号之内,每一个值被逗号分隔。如果直接赋值,不指定数组长度,系统会根据元素个数自动确定。

下面将一组值“{"today","is","a","sunny","day"}”赋给s1数组。该数组初始化之后,它的长度为5,它的元素的值分别为today、is、a、sunny和day。

string[] s1 = {"today","is","a","sunny","day"};  //给string型的数组s1赋初值

注意:如果使用上述方法初始化数组,那么该数组的长度由其值(如“{"today","is","a","sunny","day"}”)所包含单个值的数量决定。

2.实例化赋值+指定长度

实例化赋值+指定长度是给数组的每个元素赋值,而且指定数组长度。如果赋值的个数超过了数组长度,那么编译器就会报错。假如数组长度为5,赋值个数为6,提示错误信息为:应输入长度为”5”的数组初始值

下面将一组值“{"today","is","a","sunny","day"}”赋给s2数组。该初始化操作使用new操作符,并指定了数组的长度为5。该数组初始化之后,它的元素的值分别为today、is、a、sunny和day。

string[] s2 = new string[5]{"today","is","a","sunny","day"};       //使用new初始化数组s2,并指定数组长度为5

注意:如果使用上述方法初始化数组,那么值(如“{"today","is","a","sunny","day"}”)所包含单个值的数量必须等于数组的长度。

3.实例化赋值+省略长度

实例化赋值+省略长度是给数组的每个元素赋值,而不指定数组长度。数组长度根据赋值的个数自动确定。

下面将一组值“{"today","is","a","sunny","day"}”赋给s3数组。该初始化操作使用new操作符,但是省略数组的长度。该数组初始化之后,它的长度为5。它的元素的值分别为today、is、a、sunny和day。

string[] s3 = new string[]{"today","is","a","sunny","day"};      //使用new初始化数组s3,省略数组的长度

注意:如果使用上述方法初始化数组,那么该数组的长度由其值(如“{"today","is","a","sunny","day"}”)所包含单个值的数量决定。

4.直接设置数组的每一个元素的值

下面创建一个名称为s4的数组,元素类型为string,然后使用for语句直接设置s4数组的每一个元素的值。

string[] s4 = new string[5];      //创建s4数组

for(int i = 0; i < 5; i++)         //使用for语句直接设置s4数组的每一个元素的值{

    s4[i] = i.ToString();

}

 

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        public void Print(string[] s)
        {
            string[] str;
            str = s;
            for (int i = 0; i < str.Length; i++)
            {
                Console.Write(str[i] + " ");
            }
            Console.WriteLine();
        }
        static void Main(string[] args)
        {
            Program p = new Program();
            string[] s1 = { "Tody", "is", "a", "sunday", "day" };  //直接赋值
            string[] s2 = new string[5] { "Tody", "is", "a", "sunday", "day" };  //指定数组的长度在赋值
            string[] s3 = new string[] { "Tody", "is", "a", "sunday", "day" };   //省略了数组的长度在赋值
            string[] s4 = new string[5];                //for循环赋值
            for (int i = 0; i < s4.Length; i++)
            {
                s4[i] = i.ToString();
            }
            p.Print(s1);
            p.Print(s2);
            p.Print(s3);
            p.Print(s4);
            Console.ReadKey();
        }
    }
}

遍历数组

在编程中,给数组元素赋值或者打印输出数组元素的值等,都需要遍历数组。遍历数组是指依次访问数组中的每一个元素,并执行预先设计的操作。遍历数组有两种方式:一是使用下标遍历,如for、while、do…while等语句。二是不使用下标遍历,如foreach语句。

1.使用下标遍历数组

使用下标遍历数组时,即直接通过下标来确定被访问的元素。这种方法是最常用的,也是最直接的方法。

下面使用for语句遍历str数组每一个元素,并设置每一个元素的值等于该元素的下标。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        public void Print(string[] s)         //方法Print();
        {
            string[] str = s;
            for (int i = 0; i < str.Length; i++)
            {
                Console.Write(str[i] + " ");
            }
            Console.ReadKey();
        }
        static void Main(string[] args)
        {
            string[] str = new string[10];
            for (int i = 0; i < str.Length; i++)        // 赋值
            {
                str[i] = i.ToString();
            }
            Program p = new Program();    // 实例化类
            p.Print(str);
            Console.ReadKey();
        }
    }
}

2.不使用下标遍历数组

有的时候,我们遍历数组时无法判断数组元素的个数,就需要使用foreach语句枚举数组中的每一个元素来实现遍历数组的功能。而且,使用foreach语句遍历数组也可以增加代码的通用性,便于处理各种长度的数组。

下面使用foreach语句遍历str数组的每一个元素,并打印每一个元素的值。其中,s为临时变量,它的类型为str数组的元素类型。foreach语句将枚举str数组中的每一个元素,从而实现遍历str数组的功能。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] str = new string[10];
            for (int i = 0; i < str.Length; i++)
            {
                str[i] = i.ToString();
            }
            foreach (string s in str)
            {
                Console.Write(s + " ");
            }
            Console.ReadKey();
        }
    }
}

数组的类型

前面我们介绍的示例中用的是一维数组,但数组不是只有一种。根据维度数和元素类型的不同,可将数组分为四类:一维数组、二维数组、多维数组和交错数组。介绍各种数组的声明、实例化和初始化的方法。

一维数组

一维数组是指维度数为1的数组,它是一个相关变量的列表,在编程中很常见。一维数组是最简单的数组,也是最常用的数组。声明一维数组的语法如下。

type[] arrayName;其中,type表示数组元素的类型,如int、double、string、object等;arrayName表示数组的名称。

 

下面声明一个一维数组,它的元素类型为string,名称为arr1。

string[] arr1;                         //声明string型的一维数组arr1

如果要使用arr1数组,则需要实例化该数组,即为arr1数组分配相应的内存。

下面实例化数组arr1,并为该数组分配10个string类型系统预定义大小的内存。

string[] arr1 = new string[10];    //实例化数组arr

arr1数组实例化后,每个元素的值都为string类型的默认值(即空字符串)。如果要使得该数组具有实际运算意义,则还需要初始化该数组的每一个元素的值。

使用for语句依次访问arr1数组中的每一个元素,并设置每一个元素的值等于它的下标组成的字符串。

for(int i = 0; i < 10; i++)             //使用for语句访问arr1数组的元素

{

    arr1[i] = i.ToString();             //对元素进行赋值

}

下面程序中创建一个一维数组arr1,赋初值后使用foreach语句依次访问arr1数组中的每一个元素,并打印输出各数组元素。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] arr1 = { "Hello", ",", "everyday", "!" };
            foreach (string s in arr1)
            {
                Console.Write(s + " ");
            }
            Console.ReadKey();
        }
    }
}

二维数组

生活中,有很多事物,仅仅用一维数组,将无法恰当地被表示。二维数组是指维度数为2的数组。

声明二维数组的语法如下所示。

type[,] arrayName;其中,type表示数组元素的类型,如int、double、string、object等;中括号([])中间存在一个逗号(,)表示该数组为一个二维数组;arrayName表示数组的名称。

下面声明一个二维数组,它的元素类型为string,名称为arr2。

string[,] arr2;           //声明一个二维数组arr2

如果要使用arr2数组,和一维数组一样,则也需要实例化该数组,即为arr2数组分配相应的内存。

下面实例化数组arr2,并为该数组分配相应的内存。arr2数组的维度数分别为5和10,因此该数组分配大小为“5×10×string类型系统预定义大小”的内存。

string[,] arr2 = new string[5,10];  //实例化数组arr2

arr2数组实例化后,每个元素的值都为string类型的默认值(即空字符串)。如果要使得该数组具有实际运算意义,则还需要初始化该数组的每一个元素的值。

下面使用两个for语句依次访问arr2数组中的每一个元素,并设置每一个元素的值等于它的两个下标(arr2数组为二维数组,每一个元素所在的每一个维度都将存在一个下标值)组成的字符串。

for(int i = 0; i < 10; i++)

{

    for(int j = 0; j < 50; j++)              //使用for语句访问arr2数组的元素   

   {

        arr2[i,j] = i.ToString() + j.ToString();          //对元素进行赋值   

   }

}

下面程序中创建一个二维数组arr2,赋初值后使用双层for循环语句依次访问arr2数组中的每一个元素,并打印输出各数组元素。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string[,] arr2 = new string[5, 10];
            for (int i = 0; i < 5; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    arr2[i, j] = i.ToString() + j.ToString();     //赋值
                }
            }
            for (int i = 0; i < 5; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    Console.Write(arr2[i, j] + " ");     //输出
                }
                Console.WriteLine();
            }
            Console.ReadKey();
        }
    }
}

多维数组

虽然一维数组和二维数组是编程中比较常用的数组,但有时也会用到多维数组。多维数组是指维度数大于2的数组,如三维数组、四维数组等。声明三维数组的语法如下。

type[, ,] arrayName;

其中,type表示数组元素的类型,如int、double、string、object等;中括号([])中间存在两个逗号(,)表示该数组为一个三维数组;arrayName表示数组的名称。

下面声明一个三维数组,它的元素类型为string,名称为arr3。

string[, ,] arr3;               //声明一个三维数组arr3

如果要使用arr3数组,和一维数组一样,则也需要实例化该数组,即为arr3数组分配相应的内存。

下面实例化数组arr3,并为该数组分配相应的内存。arr3数组的维度数分别为5、10和50,因此该数组分配了大小为“5×10×50×string类型系统预定义大小”的内存。

string[, ,] arr3 = new string[5,10,50];  //实例化三维数组arr3

arr3数组实例化后,每个元素的值都为string类型的默认值(即空字符串)。如果要使得该数组具有实际运算意义,则还需要初始化该数组的每一个元素的值。

下面使用3个for语句依次访问arr3数组中的每一个元素,并设置每一个元素的值等于它的3个下标(arr3数组为三维数组,每一个元素所在的每一个维度都将存在一个下标值)组成的字符串。

for(int i = 0; i < 5; i++)

{

    for(int j = 0; j < 10; j++)          //使用for语句访问arr3数组的元素

    {

        for(int k = 0; k < 50; k++)

        {  //对元素进行赋值           

            arr3[i,j,k] = i.ToString() + j.ToString()+k.ToString();

        }

    }

}

下面程序中创建一个三维数组arr3,赋初值后使用三层for循环语句依次访问arr3数组中的每一个元素,并打印输出各数组元素。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string[, ,] arr3 = new string[2, 3, 4];                //创建一个三维数组
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 4; k++)
                    {
                        arr3[i, j, k] = i.ToString() + j.ToString() + k.ToString();        //赋值
                    }
                }
            }
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 4; k++)
                    {
                        Console.Write(arr3[i, j, k] + " ");            //输出
                    }
                    Console.WriteLine();
                }
                Console.WriteLine();
            }
            Console.ReadKey();
        }
    }
}

交错数组

在上面创建二维数组时,创建的是矩形数组。如果将二维数组看作表时,矩形数组就是每行长度都相等的二维数组。但有的时候需要建立的数组是每一行长度不一样的数组,这就需要交错数组了。交错数组又称为“数组的数组”,它的元素也为一个数组,但每一行包含的列数不同。声明二维交错数组的语法如下所示。

type[][] arrayName;其中,type表示数组元素的类型,如int、double、string、object等;type关键字之后包含两个中括号([])表示该数组为一个二维交错数组;arrayName表示数组的名称。

下面声明一个二维交错数组,它的元素类型为string,名称为arr4。

string[][] arr4;        //声明一个二维交错数组arr4

如果要使用arr4数组,和一维数组一样,则也需要实例化该数组,即为arr4数组分配相应的内存。

下面实例化数组arr4,并为该数组分配相应的内存。arr4数组的第一维度数为10,它的每一个元素也是一个数组,它们的长度分别为1、2、3、4、5、6、7、8、9和10。

string[][] arr4 = new string[10][];   //声明一个二维交错数组arr4

for(int i = 0; i < 10; i++)

{

    arr4[i] = new string[i + 1];       //为第二维设定长度

}

arr4数组实例化后,每个元素的值都为string类型的默认值(即空字符串)。如果要使得该数组具有实际运算意义,则还需要初始化该数组的每一个元素的值。

下面使用2个for语句依次访问arr4数组中的每一个元素,并设置每一个元素的值等于它的2个下标(arr4数组为三维数组,每一个元素所在的每一个维度都将存在一个下标值)组成的字符串。

for(int i = 0; i < 10; i++)

{

      for(int j = 0; j < arr4[i].Length; j++)        //使用for语句访问arr4数组的元素   

   {

        arr4[i][j] = i.ToString() + j.ToString();    //对元素进行赋值

    }

}

下面程序中创建一个交错数组arr4,使用for循环语句依次访问arr4数组中的每一个元素,并打印输出各数组元素。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string[][] arr4 = new string[10][];     //声明一个交错数组并实例化
            for (int i = 0; i < 10; i++)      //使用for循环为第二维设定长度(设置行的长度)
            {
                arr4[i] = new string[i + 1];  //设置行设置列的长度
            }
            for (int i = 0; i < 10; i++)   //使用for循环遍历元素
            {
                for (int j = 0; j < arr4[i].Length; j++)
                {
                    arr4[i][j] = i.ToString() + j.ToString();  //给元素赋值
                }
            }
            for (int i = 0; i < 10; i++)
            {
                for (int j = 0; j < arr4[i].Length; j++)
                {
                    Console.Write(arr4[i][j] + " ");
                }
                Console.WriteLine();
            }
            Console.ReadKey();
        }
    }
}

静态数组System.Array

在编程中,有的数组大小设置好以后就不能让它随意地被修改,有的又想要根据需要来设置大小。因此.NET框架提供了两种数组:静态数组和动态数组。一旦为数组分配内存之后,如果该数组的大小是不能修改的,则称该数组为静态数组;反之,则称之为动态数组。静态数组由System.Array类实现,动态数组由System.ArrayList类实现。介绍静态数组的基本属性和方法,以及它们的使用方法。

常用属性

数组有各种特性,如数组长度、数组的秩等。为了方便用户使用类Array,微软将一些常用的属性封装到该类中。这些属性可以获取静态数组的特性。System.Array类包含7个属性,如获取数组长度的Length属性、获取数组秩的Rank等,具体如下。

属性                                       描述
IsFixedSize               表示数组的大小是否固定
IsReadOnly               表示数组是否为只读
IsSynchronized        表示是否同步访问数组
Length                       数组的长度,即数组所有维度中元素的总数。该值为32位整数
LongLength              数组的长度,即数组所有维度中元素的总数。该值为64位整数
Rank                          数组的秩,即数组的维度数
SyncRoot                  获取同步访问数组的对象

常用方法

在编程中,会对数组有各种各样的操作。为了方便用户使用类Array,微软还将一些常用的方法封装到该类中。调用这些方法可以执行对静态数组的操作。System.Array类包含多个方法,如获取数组长度使用GetLength()方法、获取指定元素的值使用GetValue()方法,获取指定元素的索引使用IndexOf()方法等,具体如下。

方法                                                      描述
BinarySearch()                      使用二进制搜索算法在一维的排序数组中搜索指定元素
Clear()                                    清空数组中的所有元素
Clone()                                   复制数组
ConstrainedCopy()               指定开始位置,并复制一系列元素到另外一个数组中
Copy()                                    将一个数组中的一部分元素复制到另一个数组
CopyTo()                               将一维数组的所有元素复制到另外一个一维数组
FindIndex()                           搜索指定元素,并获取第一个匹配元素的索引
FindLastIndex()                    搜索指定元素,并获取最后一个匹配元素的索引
GetLength()                          获取指定维的元素数量。该值为32位整数
GetLongLength()                 获取指定维的元素数量。该值为64位整数
GetLowerBound()                获取数组中指定维度的下限
GetUpperBound()                获取数组中指定维度的上限
GetValue()                            获取指定元素的值
IndexOf()                               获取匹配的第一个元素的索引
LastIndexOf()                       获取匹配的最后一个元素的索引
Reverse()                              反转一维数组中元素的顺序
SetValue()                             设置指定元素的值
Sort()                                      对一维数组中的元素进行排序

下面创建一个一维数组arr。该示例使用SetValue()方法设置该数组中的每一个元素的值,使用GetValue()方法获取该数组中索引值为8的元素的值,并保存为value变量。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = new int[13];
            for (int i = 0; i < arr.Length; i++)    //遍历
            {
                arr.SetValue(i, i);  //设置数组元素的值
            }
            int value = (int)arr.GetValue(8);
            Console.WriteLine("value = " + value);
            Console.ReadKey();
        }
    }
}

获取数组长度

在编程中,数组的操作有时需要使用for循环,而又不确定范围,就可以先获取数组的长度。数组长度是指数组元素的总数,即数组每一维度元素数量之乘积。数组长度可以通过System.Array类的属性或者方法获取。

1.通过属性获取数组的长度

通过Length和LongLength属性都可以获取数组的长度。Length属性的值为int类型,LongLength属性的值为long类型。如果数组的长度不大于32位整数,就可以使用Length属性获取;如果数组长度大于32位整数且小于64位整数,则需要通过LongLength属性来获取数组的长度。

下面获取arr1数组的长度,并保留为length变量。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] arr1 = new int[10, 100];
            int length = arr1.Length;
            Console.WriteLine("数组的长度为:" + length);
            Console.ReadKey();
        }
    }
}

2.通过方法获取数组的长度

通过GetLength(int dimension)和GetLongLength(int dimension)方法都可以获取数组中指定维度的元素的数量。其中,dimension参数表示数组的维度。

下面使用for语句获取arr数组每一个维度的长度,然后把这些长度相乘,结果就是arr数组的长度,并保留为length变量。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] arr3 = new int[5, 10];
            int length = 1;
            for (int i = 0; i < arr3.Rank; i++)
            {
                length *= arr3.GetLength(i);  //调用GetLength()方法获得数组的下标
            }
            Console.WriteLine(length);
            Console.ReadKey();
        }
    }
}

 

GetLength(int dimension)方法返回值为int类型,GetLongLength(int dimension)方法返回值为long类型。如果数组某一个维度的长度大于32位整数,则只能通过GetLongLength(int dimension)方法来获取数组的长度。

 获取元素的值

有时候我们只想使用数组中某个特定的值,那么获取数组中指定元素的值最简单方法就是通过“[]”运算符。

下面获取arr数组中第0行、第3列元素的值,并保留为value变量。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] arr = new int[5, 10];
            for (int i = 0; i < 5; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    arr[i, j] = i + j;    //赋值
                }
            }
            int value = arr[0, 3];      //获取数组中的值
            Console.WriteLine(value);
            Console.ReadKey();
        }
    }
}

除了上述方法之外,还可以通过GetValue()方法获取指定元素的值。

下面通过GetValue()方法获取arr数组中第0行、第5列元素的值,并保留为value变量。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] arr = new int[5, 10];
            for (int i = 0; i < 5; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    arr[i, j] = i + j;   //对元素赋值
                }
            }
            int value = (int)arr.GetValue(0, 5);  //调用GetValue()方法获取数组中的值
            Console.WriteLine(value);
            Console.ReadKey();
        }
    }
}

设置元素的值

在编程中,有时我们只关心数组中某个元素的值。可以通过两种方式来设置指定数组元素的值:通过数组名和“[]”运算符或者通过SetValue()方法来设置指定元素的值。

下面设置arr数组中第0行、第1列元素的值为200。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] arr = new int[5, 10];        //定义二维数组
            for (int i = 0; i < 5; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    arr[i, j] = i + j;
                }
            }
            arr.SetValue(200, 0, 1);           //调用函数赋值
            int value = (int)arr.GetValue(0, 1);  
            Console.WriteLine(value);
            Console.ReadKey();
        }
    }
}

通过数组名和“[]”运算符设置arr数组第零行第一列的元素的值。

获取元素的索引

有时需要得到数组中某个元素的索引值,System.Array类为一维数组提供了获取元素的索引的两个静态方法:IndexOf()和LastIndexOf()方法。IndexOf()方法获取匹配的、第一个元素的索引。LastIndexOf()方法获取匹配的、最后一个元素的索引。

下面获取array数组中值为10的、第一个元素的索引值和最后一个元素的索引值,分别保存为sindex和eindex变量。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[1000];
            int sindex = Array.IndexOf(array, 10);
            int eindex = Array.LastIndexOf(array, 10);
            Console.WriteLine(sindex);
            Console.WriteLine(eindex);
            Console.ReadKey();
        }
    }
}

注意:IndexOf()和LastIndexOf()方法只能用于获取一维数组元素的索引值。

排序数组

在现实生活中,有时需要对数组元素的值进行排序,比如学生成绩按降序排列。System.Array类为一维数组提供了一个名称为“Sort()”的方法,该方法可以对一维数组中的元素进行排序。能够使用Sort()方法排序的数组中的元素必须实现IComparable接口,即数组中的元素是能够进行比较的,否则不能对该数组中的元素进行排序。

下面调用Sort()方法对arr数组中的元素进行排序。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 5, 6, 1, 8, 4, 0 };
            Array.Sort(arr);     //调用Sort方法对数组排序
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + " ");
            }
            Console.ReadKey();
        }
    }
}

注意:Sort()方法排序算法为快速排序(QuickSort)算法。因此,Sort()方法是不稳定排序,且算法的时间复杂度为O(nlogn)。其中,n为数组的长度。

反转数组

有时候需要将数组中的元素反过来排列,System.Array类为一维数组提供了一个名称为Reverse()的方法。该方法可以反转一维数组中的全部元素或部分连续的元素。

下面调用Reverse()方法反转arr数组中的所有元素。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 5, 6, 1, 8, 4, 0 };
            Array.Reverse(arr);   //调用Reverse方法 反转数组元素
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + " ");
            }
            Console.ReadKey();
        }
    }
}

下面调用Reverse()方法反转array数组中的、从第3个元素开始的、连续3个元素。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 5, 6, 1, 8, 4, 0, 10, 11 };
            Array.Reverse(arr, 3, 3);      //调用Reverse方法反转数组元素
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + " ");
            }
            Console.ReadKey();
        }
    }
}

动态数组System.ArrayList

在编程中,有时候需要数组长度可以改变的、存储不同数据类型的数组。动态数组的出现就解决了这种问题。动态数组又称为可变数组,且数组的长度可以动态修改。动态数组由System.ArrayList类实现,它在保存元素时,仅仅保存元素的引用,而不是元素的具体值。因此,动态数组元素的数据类型可以是任何类型,而且各个元素的数据类型也可以不相同。

下面创建一个名称为myList的动态数组,并添加了4个元素。第1个元素的值为2013,数据类型为整数。第2个元素为“11月20日”,数据类型为字符串。第3个元素为A字符,数据类型为字符型。第4个元素为Program类的实例p,类型为Program。然后使用foreach语句遍历myList动态数组中的每一个元素,并打印到控制台。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList myList = new ArrayList();
            myList.Add(2013);    
            myList.Add("11月20日");
            myList.Add("A");        //字符串
            Program p = new Program();
            myList.Add(p);            //实例对象
            foreach (object obj in myList)   //遍历打印
            {
                Console.WriteLine(obj);
            }
            Console.ReadKey();
        }
    }
}

注意:由于所有数据类型的基类型都是object。因此,动态数组中的所有元素都可以直接或间接地转换为object类型。所以,在遍历myList动态数组中的元素时,foreach语句使用object类型来表示myList动态数组元素的数据类型。

常用属性

动态数组有各种特性,如数组容量、数组元素的数量等。为了方便用户使用类ArrayList,微软将一些常用的属性封装到该类中。这些属性可以获取动态数组的特性。System.ArrayList类包含了7个属性,如获取数组元素数量的Count属性、指示数组是否为只读的ReadOnly属性等,具体如下。

属性                     描述                                         属性                               描述
Capacity             数组的容量                              IsReadOnly                  表示数组是否为只读
Count                  数组元素的数量                      IsSynchronized           表示是否同步访问数组
IsFixedSize        表示数组的大小是否固定       SyncRoot                     获取同步访问数组的对象
Item                     指定索引处的元素    

常用方法

在编程中,对数组有各种各样的操作。为了方便用户使用类ArrayList,微软还将一些常用的方法封装到该类中。调用这些方法可以执行对动态数组的操作。System.ArrayList类包含了多个方法,如添加新元素到数组末尾中的Add()方法、从数组中删除指定元素的Remove()方法等,具体如下。

方法                               描述
Add()                         添加元素到数组的末尾
AddRange                将ICollection的元素添加到数组的末尾
BinarySearch           使用二分查找算法搜索已排序的数组中的指定元素
Clear()                       清空数组中的所有元素
Contains()                 判断数组中是否存在指定的元素
CopyTo                     将数组或其一部分复制到一维数组中
GetRange                 获取数组的一个子集
IndexOf()                   获取指定元素在数组中的第一个位置(或索引),从数组的开头处开始查找
Insert()                       插入元素到数组的指定位置
InsertRange              将集合中的某个元素插入数组的指定位置
LastIndexOf()           获取指定元素在数组中的第一个位置(或索引),从数组的末尾处开始查找
Remove()                  从数组中移除指定的元素
RemoveAt()              从数组中移除指定位置的元素
RemoveRange         从数组中移除一定范围的元素
Reverse                    将数组或其一部分中元素的顺序反转
SetRange                  将集合中的元素复制到数组中一定范围的元素上
Sort                            对数组或其一部分中的元素进行排序
ToArray                     将数组的元素复制到新数组(一维数组)中

下面首先创建两个数组:一个名称为“myList”的动态数组,另外一个名称为“arr”的静态数组。然后调用CopyTo()方法将myList数组中的元素复制到newarr数组中。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList myList = new ArrayList();
            myList.Add(2013);
            myList.Add("11月20日");
            myList.Add("A");
            Program p = new Program();
            myList.Add(p);
            foreach (object obj in myList)
            {
                Console.WriteLine(obj + " ");
            }
            object[] arr = new object[myList.Count];
            myList.CopyTo(arr);                 // 拷贝数组
            Console.WriteLine("");
            foreach (object obj in arr)
            {
                Console.WriteLine(obj + " ");
            }
            Console.ReadKey();
        }
    }
}

添加元素

在编程中,如果数组中缺少程序需要的数据,就要给数组添加元素。给动态数组添加元素可使用Add()方法或者Insert()方法。Add()方法是在数组末尾添加元素,而Insert()方法可以在指定的位置添加元素。

下面程序中创建了一个动态数组list。然后分别调用Add()方法和Insert()方法给list数组添加元素: “Today is a sunny day.”和“这是一个动态数组list.” 。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();
            list.Add("Today is a sunny day");   //添加元素

            list.Insert(0, "这是一个动态数组list");  //插入元素
            foreach (object obj in list)
            {
                Console.WriteLine(obj + " ");
            }
            Console.ReadKey();
        }
    }
}

移除元素

在编程中,如果数组中有冗余数据,则需要将其移除。从动态数组中移除元素可使用Remove()、RemoveAt()或RemoveRange()方法。

Remove()方法是移除数组中指定的元素,

RemoveAt()方法是移除数组中指定位置的元素,

RemoveRange()方法是移除数组中指定范围内的元素。

下面程序中首先给list数组添加三个元素:“这是一个动态数组list.”、2013和“Today is a sunny day.”。其中,2012位于list数组的末尾处。然后,调用Remove()方法从list数组中移除“这是一个动态数组list.”元素。再调用RemoveAt()方法移除list数组中索引为1处的元素(即第二个元素)。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();
            list.Add("这是一个动态数组list.");
            list.Add("Today is a sunny day.");
            list.Add(2013);
            foreach (object obj in list)
            {
                Console.WriteLine(obj + " ");
            }
            Console.WriteLine();
            list.Remove("这是一个动态数组list."); //移除这是一个动态数组list.
            foreach (object obj in list)
            {
                Console.WriteLine(obj + " ");
            }
            Console.WriteLine();
            list.RemoveAt(1); //移除第二个元素
            foreach (object obj in list)
            {
                Console.WriteLine(obj + " ");
            }
            Console.ReadKey();
        }
    }
}

------- Windows Phone 7手机开发.Net培训、期待与您交流! ------- 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值