C#常用数据结构与算法

第7章常用数据结构与算法数据结构和算法是程序设计的基石。本章重点讲述C#中的几个主要的数据结构类型：字符串、数组和枚举。本章还将介绍一些常用算法，如几种典型排序算法的C#实现。2023/2/42C#程序设计实用教程

7.1字符串

字符串是应用程序和用户交互的主要方式之一。.NET提供了几个类来快速实现字符串操作，包括String、StringBuilder等。2023/2/43C#程序设计实用教程

7.1.1静态字符串String

System.String是最常用的字符串操作类。下面从各个应用的角度对String类进行详细的介绍。

1.比较字符串比较字符串是指按照字典排序规则，判定两个字符的相对大小。在String类中，常用的比较字符串的方法包括Compare、CompareTo、CompareOrdinal以及Equals。2023/2/44C#程序设计实用教程方法说明Compare静态方法。比较两个指定的String对象CompareTo

非静态方法。将此字符串与指定的对象或String进行比较，并返回两者相对值的指示Concat

静态方法。连接String的一个或多个字符串Contains非静态方法。返回一个值，该值指示指定的String对象是否出现在此字符串中Equals非静态方法。确定两个String对象是否具有相同的值Format静态方法。将指定的String中的每个格式项替换为相应对象的值的文本等效项IndexOf

非静态方法。返回String或一个或多个字符在此字符串中的第一个匹配项的索引Insert非静态方法。在该String中的指定索引位置插入一个指定的StringRemove非静态方法。从该String中删除指定个数的字符Replace非静态方法。将该String中的指定String的所有匹配项替换为其他指定的StringSplit非静态方法。返回包含该String中的子字符串（由指定Char或String数组的元素分隔）的String数组Substring非静态方法。从此字符串中检索子字符串ToLower

非静态方法。返回该String转换为小写形式的副本ToUpper

非静态方法。返回该String转换为大写形式的副本Trim非静态方法。从此字符串的开始位置和末尾移除一组指定字符的所有匹配项串的基本概念

空串：不含任何字符的串称为空串空格串：由一个或多个空格组成的串，称为空格串。串相等：是指两个串的长度相等且对应的字符相等。模式匹配：确定子串在主串中首次出现位置的运算。子串：串中任意个连续的字符组成的子序列称为该串的子串。主串：包含子串的串称为该子串的主串。

7.1.1静态字符串String

（1）Compare方法Compare方法是String类的静态方法，用于全面比较两个字符串对象。

下面使用Compare方法来比较两个字符串，输出结果如注释语句所示。

//定义两个String对象，并对其赋值

System.String

strA="Hello";System.String

strB="World";

2023/2/47C#程序设计实用教程

7.1.1静态字符串String

//CompareConsole.WriteLine(String.Compare(strA,strB)); //-1Console.WriteLine(String.Compare(strA,strA)); //0Console.WriteLine(String.Compare(strB,strA)); //12023/2/48C#程序设计实用教程

7.1.1静态字符串String

（2）CompareTo方法

CompareTo方法将当前字符串对象与另一个对象做比较，其作用与Compare类似，返回值也相同。

CompareTo与Compare相比，区别在于：

CompareTo不是静态方法，可以通过一个String对象调用；

CompareTo没有重载形式，只能按照大小写敏感方式比较两个整串。

2023/2/49C#程序设计实用教程

7.1.1静态字符串String

CompareTo方法的使用如下代码所示：

//定义两个String对象，并对其赋值

System.String

strA="Hello";System.String

strB="World";

//CompareTo

Console.WriteLine(strA.CompareTo(strB)); //-12023/2/410C#程序设计实用教程

7.1.1静态字符串String

（3）Equals方法Equals方法用于方便地判定两个字符串是否相同，有两种重载形式：

publicbool

Equals(string)publicstaticbool

Equals(string,string)如果两个字符串相等，Equals()返回值为True；否则，返回False。Equals方法的使用如下代码所示：

//EqualsConsole.WriteLine(String.Equals(strA,strB)); //falseConsole.WriteLine(strA.Equals(strB)); //false2023/2/411C#程序设计实用教程

7.1.1静态字符串String

（4）比较运算符String支持两个比较运算符“==”、“!=”，分别用于判定两个字符是否相等和不等，并区分大小写。下例中，使用“==”、“!=”对“Hello”和“World”进行比较。

//==和!=Console.WriteLine(strA==strB); //falseConsole.WriteLine(strA!=strB); //true2023/2/412C#程序设计实用教程

7.1.1静态字符串String

2.定位字符和子串定位子串是指在一个字符串寻找其中包含的子串或者某个字符，在String类中，常用的定位子串和字符的方法包括StartWith/EndsWith、IndexOf/LastIndexOf以及IndexOfAny/LastIndexOf。

2023/2/413C#程序设计实用教程

7.1.1静态字符串String

（1）StartWith/EndsWith方法StartWith方法可以判定一个字符串对象是否以另一个子字符串开头，如果是返回True；否则返回False。其定义为：

publicbool

StartsWith(stringvalue)其中，参数value即待判定的子字符串。

//StartWith

Console.WriteLine(strA.StartsWith("He"));//trueConsole.WriteLine(strA.StartsWith("She"));//false另外，EndsWith方法可以判定一个字符是否以另一个子字符串结尾。

2023/2/414C#程序设计实用教程

7.1.1静态字符串String

（2）IndexOf/LastIndexOf方法IndexOf方法用于搜索一个字符串，某个特定的字符或子串第一次出现的位置，该方法区分大小写，并从字符串的首字符开始以０计数。如果字符串中不包含这个字符或子串，则返回-1。定位字符：

int

IndexOf(charvalue)int

IndexOf(char

value,int

startIndex)int

IndexOf(char

value,int

startIndex,intcount)2023/2/415C#程序设计实用教程

7.1.1静态字符串String

定位子串：

int

IndexOf(stringvalue)int

IndexOf(string

value,int

startIndex)int

IndexOf(string

value,int

startIndex,intcount)在上述重载形式中，其参数含义如下：

Value：待定位的字符或者子串。

startIndex：在总串中开始搜索的起始位置。

Count：在总串中从起始位置开始搜索的字符数。

2023/2/416C#程序设计实用教程

7.1.1静态字符串String

下例在“Hello”中寻找字符“l”第一次出现的位置。

//Indexof

Console.WriteLine(strA.IndexOf('l')); //2同IndexOf类似，LastIndexOf用于搜索在一个字符串中，某个特定的字符或子串最后一次出现的位置，其方法定义和返回值都与IndexOf相同。2023/2/417C#程序设计实用教程

7.1.1静态字符串String

（3）IndexOfAny/LastIndexOfAny

IndexOfAny方法功能同IndexOf类似，区别在于，可以搜索在一个字符串中，出现在一个字符数组中的任意字符第一次出现的位置。2023/2/418C#程序设计实用教程

7.1.1静态字符串String

下例在“Hello”中寻找字符“l”第一次和最后一次出现的位置。

//IndexofAny|LastIndexOfAny

char[]anyOf={'H','e','l'};Console.WriteLine(strA.IndexOfAny(anyOf)); //0Console.WriteLine(strA.LastIndexOfAny(anyOf)); //3同IndexOfAny类似，LastIndexOfAny用于搜索在一个字符串中，出现在一个字符数组中任意字符最后一次出现的位置。

2023/2/419C#程序设计实用教程

7.1.1静态字符串String

3.格式化字符串Format方法用于创建格式化的字符串以及连接多个字符串对象。Foramt方法也有多个重载形式，最常用的为：

publicstaticstringFormat(string

format,paramsobject[]args);其中，参数format用于指定返回字符串的格式，而args为一系列变量参数。

2023/2/420C#程序设计实用教程

7.1.1静态字符串String

//FormatnewStr="";newStr=String.Format("{0},{1}!",strA,strB);Console.WriteLine(newStr); //Hello,World!在format参数中包含一些用大括号括起来的数字，如{0}、{1}，这些数字分别一一对应于args参数数组中的变量。在生成结果字符串时，将使用这些变量代替{i}。需要说明的是，这些变量并不要求必须为String类型。

2023/2/421C#程序设计实用教程

7.1.1静态字符串String

例如，想要输出一定格式的时间字符串，便可以使用Format方法，如下面代码所示。

newStr=String.Format("CurrentTime={0:yyyy-MM-dd}",System.DateTime.Now);Console.WriteLine(newStr); //形如：2008-09-19其中，格式字符串“yyyy-MM-dd”指定返回时间的格式形如“2008-09-19”。

2023/2/422C#程序设计实用教程

7.1.1静态字符串String

4.连接字符串（1）

Concat方法

Concat方法用于连接两个或多个字符串//Concat

newStr="";newStr=String.Concat(strA,"",strB);Console.WriteLine(newStr); //“HelloWorld"2023/2/423C#程序设计实用教程

7.1.1静态字符串String

（2）Join方法

Join方法利用一个字符数组和一个分隔符串构造新的字符串。常用于把多个字符串连接在一起，并用一个特殊的符号来分隔开。Join方法的常用形式为：

publicstaticstringJoin(string

separator,string[]values);其中，参数separator为指定的分隔符，而values用于指定所要连接的多个字符串数组。2023/2/424C#程序设计实用教程

7.1.1静态字符串String

下例用“^^”分隔符把“Hello”和“World”连起来。

//JoinnewStr="";String[]strArr={strA,strB};newStr=String.Join("^^",strArr);Console.WriteLine(newStr); //"Hello^^World"2023/2/425C#程序设计实用教程

7.1.1静态字符串String

（3）连接运算符“+”String支持连接运算符“+”，可以方便地连接多个字符串。例如，下例把“Hello”和“World”连接起来。

//+newStr="";newStr=strA+strB;Console.WriteLine(newStr); //"HelloWorld"2023/2/426C#程序设计实用教程

7.1.1静态字符串String

5.分隔字符串使用Split方法可以把一个整串，按照某个分隔符，分裂成一系列小的字符串。例如，把整串，按照某个分隔符，分裂成一系列小的字符串。例如，把整串“Hello^^World”按照字符“^”进行分裂，可以得到3个小的字符串，即“Hello”、“”（空串）和“World”。Split方法最常用的形式为：

publicstring[]Split(paramschar[]separator);其中，参数separator数组包含分隔符。2023/2/427C#程序设计实用教程

7.1.1静态字符串String

//SplitnewStr="Hello^^World";char[]separator={'^'};String[]splitStrings=newString[100];splitStrings=newStr.Split(separator);inti=0;while(i<splitStrings.Length){ Console.WriteLine("item{0}:{1}",i,splitStrings[i]); i++;}输出结果如下：

Item0:HelloItem1:Item2:World2023/2/428C#程序设计实用教程

7.1.1静态字符串String

6.插入和填充字符串String类包含了在一个字符串中插入新元素的方法，可以用Insert方法在任意插入任意字符。

Insert方法用于在一个字符串的指定位置插入另一个字符串，从而构造一个新的串。Insert方法最常用的为：

publicstringInsert(int

startIndex,stringvalue);其中，参数startIndex用于指定所要插入的位置，从０开始索引；value指定所要插入的字符串。2023/2/429C#程序设计实用教程

7.1.1静态字符串String

下例中，在“Hello”的字符“H”后面插入“World”，构造一个串“HWorldello”。

//InsertnewStr="";newStr=strA.Insert(1,strB);Console.WriteLine(newStr); //"HWorldello"2023/2/430C#程序设计实用教程

7.1.1静态字符串String

7.删除和剪切字符串String类包含了删除一个字符串的方法。可以用Remove方法在任意位置删除任意长度的字符。也可以使用Trim/TrimeEnd/TrimStart方法剪切掉字符串中的一些特定字符。

2023/2/431C#程序设计实用教程

7.1.1静态字符串String

（1）Remove方法

Remove方法从一个字符串的指定位置开始，删除指定数量的字符。最常用的形式为：

publicstringRemove(int

startIndex,intcount);其中，参数startIndex用于指定开始删除的位置，从０开始索引；count指定删除的字符数量。下例中，把“Hello”中的“ell”删掉。

//RemovenewStr="";newStr=strA.Remove(1,3);Console.WriteLine(newStr); //"Ho"2023/2/432C#程序设计实用教程

7.1.1静态字符串String

（2）Trim/TrimStart/TrimEnd方法

若想把一个字符串首尾处的一些特殊字符剪切掉，如去掉一个字符串首尾的空格等，可以使用String的Trim()方法。其形式如下：

publicstringTrim() publicstringTrim(paramschar[]trimChars)其中，参数trimChars数组包含了指定要去掉的字符，如果缺省，则删除空格符号。下例中，实现了对“@Hello#$”的净化，去掉首尾的特殊符号。

2023/2/433C#程序设计实用教程

7.1.1静态字符串String

//TrimnewStr="";char[]trimChars={'@','#','$',''};StringstrC="@Hello#$";newStr=strC.Trim(trimChars);Console.WriteLine(newStr); //"Hello"另外，同Trim类似，TrimStart和TrimEnd分别剪切掉一个字符串开头和结尾处的特殊字符。

2023/2/434C#程序设计实用教程

7.1.1静态字符串String

8.复制字符串String类包括了复制字符串方法Copy和CopyTo，可以完成对一个字符串及其一部分的复制操作。

2023/2/435C#程序设计实用教程

7.1.1静态字符串String

（1）Copy方法

若想把一个字符串复制到另一个字符数组中，可以使用String的静态方法Copy来实现，其形式为：

publicstringCopy(string

str);其中，参数str为需要复制的源字符串，方法返回目标字符串。下例中，把strA字符串“Hello”复制到newStr中。

//CopynewStr="";newStr=String.Copy(strA);Console.WriteLine(newStr); //"Hello"2023/2/436C#程序设计实用教程

7.1.1静态字符串String

（2）CopyTo方法

CopyTo方法可以实现Copy同样的功能，但功能更为丰富，可以复制字符串的一部分到一个字符数组中。其形式为：

publicvoidCopyTo(int

sourceIndex,char[]destination,int

destinationIndex,intcount);其中，参数sourceIndex为需要复制的字符起始位置，destination为目标字符数组，destinationIndex指定目标数组中的开始存放位置，而count指定要复制的字符个数。2023/2/437C#程序设计实用教程

7.1.1静态字符串String

下例中，把strA字符串“Hello”中的“ell”复制到newCharArr中，并在newCharArr中从第2个元素开始存放。

//CopyTo

char[]newCharArr=newchar[100];strA.CopyTo(2,newCharArr,0,3);Console.WriteLine(newCharArr); //”llo"2023/2/438C#程序设计实用教程

7.1.1静态字符串String

9.替换字符串想要替换一个字符串中的某些特定字符或者某个子串，可以使用Replace方法来实现，其形式为：

publicstringReplace(char

oldChar,charnewChar);publicstringReplace(string

oldValue,stringnewValue);其中，参数oldChar和oldValue为待替换的字符和子串，而newChar和newValue为替换后的新字符和新子串。下例把“Hello”通过替换变为“Hero”。

//ReplacenewStr=strA.Replace("ll","r"); Console.WriteLine(newStr); //Hero2023/2/439C#程序设计实用教程

7.1.1静态字符串String

10.更改大小写String提供了方便转换字符串中所有字符大小写的方法ToUpper和ToLower。下例首先把“Hello”转换为“HELLO”，然后再变为小写形式“hello”。

//ToUpper|ToLower

newStr=strA.ToUpper(); Console.WriteLine(newStr); //HELLOnewStr=strA.ToLower();Console.WriteLine(newStr); //hello2023/2/440C#程序设计实用教程

7.1.1静态字符串String

补充：提取子串利用字符串的提取子串方法Substring，就可从一个字符串中得到子字符串。Substring方法有两个参数，第一个参数指出从第几个位置开始截取，第二个参数指出共提取几个字符。截取以后的子串是另外一个字符串，而不是原来的字符串截短，原来的字符串不变。2023/2/441C#程序设计实用教程

7.1.1静态字符串String

usingSystem;classSubString{publicstaticvoidMain()

{stringstrOriginal="IlovesChina!";stringstrSub=strOriginal.Substring(2,12);

Console.WriteLine("strOriginal:"+strOriginal);

Console.WriteLine("strSub:"+strSub);stringstrTemp;for(inti=0;i<strOriginal.Length;i+=2)

{

strTemp=strOriginal.Substring(i,1);

Console.Write(strTemp);

}

}}2023/2/442C#程序设计实用教程

7.1.1静态字符串String

程序运行结果如下：2023/2/443C#程序设计实用教程

7.1.1静态字符串String

11.String小结本节介绍了最常用的String类，并从比较、定位子串、格式化、连接、分裂、插入、删除、复制、大小写转换10个方面介绍了其方法和应用。

之所以称String对象为静态串，是因为一旦定义一个String对象，就是不可改变的。在使用其方法（如插入、删除操作）时，都要在内存中创建一个新的String对象，而不是在原对象的基础上进行修改，这就需要开辟新的内存空间。如果需要经常进行串修改操作，使用String类无疑是非常耗费资源的，这时需要使用StringBuilder类。2023/2/444C#程序设计实用教程

7.1.2动态字符串StringBuilder

与String类相比，System.Text.StringBuilder类可以实现动态字符串。此外，动态的含义是指在修改字符串时，系统不需要创建新的对象，不会重复开辟新的内存空间，而是直接在原StringBuilder对象的基础上进行修改。2023/2/445C#程序设计实用教程

7.1.2动态字符串StringBuilder

1.声明StringBuilder串StringBuilder类位于命名空间System.Text中，使用时，可以在文件头通过using语句引入该命名空间：usingSystem.Text;声明StringBuilder对象需要使用new关键字，并可以对其进行初始化。如以下语句声明了一个StringBuilder对象myStringBuilder，并初始化为“Hello”：

StringBuilder

myStringBuilder=newStringBuilder("Hello");2023/2/446C#程序设计实用教程

7.1.2动态字符串StringBuilder

2.设置StringBuilder容量StringBuilder对象为动态字符串，可以对其设置好的字符数量进行扩展。另外，还可以设置一个最大长度，这个最大长度称为该StringBuilder对象的容量（Capacity）。2023/2/447C#程序设计实用教程

7.1.2动态字符串StringBuilder

有两种方式来设置一个StringBuilder对象的容量。（1）使用构造函数StringBuilder构造函数可以接受容量参数，例如，下面声明一个StringBuilder对象sb2，并设置其容量为100。//使用构造函数StringBuildersb2=newStringBuilder("Hello",100);2023/2/448C#程序设计实用教程

7.1.2动态字符串StringBuilder

（2）使用Capacity读/写属性Capacity属性指定StringBuilder对象的容量。例如下面语句首先一个StringBuilder对象sb3，然后利用Capacity属性设置其容量为100。//使用Capacity属性StringBuildersb3=newStringBuilder("Hello");sb3.Capacity=100;2023/2/449C#程序设计实用教程

7.1.2动态字符串StringBuilder

3.追加操作追加一个StringBuilder是指将新的字符串添加到当前StringBuilder字符串的结尾处，可以使用Append和AppendFormat来实现这个功能。（1）Append方法下例中，把一个StringBuilder字符串“Hello”追加为“HelloWorld!”。//AppendStringBuildersb4=newStringBuilder("Hello");sb4.Append("World!");Console.WriteLine(sb4); //"HelloWorld!"2023/2/450C#程序设计实用教程

7.1.2动态字符串StringBuilder

（2）AppendFormat方法AppendFormat方法可以实现对追加部分字符串的格式化，可以定义变量的格式，并将格式化后的字符串追加在StringBuilder后面。2023/2/451C#程序设计实用教程

7.1.2动态字符串StringBuilder

4.插入操作StringBuilder的插入操作是指将新的字符串插入到当前的StringBuilder字符串的指定位置，如“Hello”变为“Heeeello”。可以使用StringBuilder类的Insert方法来实现这个功能，常用形式为：publicStringBuilder

Insert(intindex,objectvalue);其中，参数index指定所要插入的位置，并从0开始索引，如index=1，则会在原字符串的第2个字符之前进行插入操作；同Append一样，参数value并不仅是只可取字符串类型。2023/2/452C#程序设计实用教程

7.1.2动态字符串StringBuilder

下例中，把一个StringBuilder字符串“Hello”通过插入操作修改为“Heeeello”。//InsertStringBuildersb6=newStringBuilder("Hello");sb6.Insert(2,"eee");Console.WriteLine(sb6); //"Heeeello"2023/2/453C#程序设计实用教程

7.1.2动态字符串StringBuilder

5.删除操作StringBuilder的删除操作可以从当前StringBuilder字符串的指定位置，删除一定数量的字符，例如把“Heeeello”变为“Hello”。可以使用StringBuilder类的Remove方法来实现这个功能，常用形式为：publicStringBuilder

Remove(int

startIndex,intlength);其中，参数startIndex指定所要删除的起始位置，其含义同Insert中的index相同；length参数指定所要删除的字符数量。2023/2/454C#程序设计实用教程

7.1.2动态字符串StringBuilder

下例中，把一个StringBuilder字符串“Heeeello”通过删除操作修改为“Hello”。//RemoveStringBuildersb7=newStringBuilder("Heeello");sb7.Remove(2,2); //在”He”后面删除个字符Console.WriteLine(sb7); //"Hello!"2023/2/455C#程序设计实用教程

7.1.2动态字符串StringBuilder

6.替换操作StringBuilder使用Replace方法来实现替换操作，例如把“Hello”变为“Hero”，就需要使用替换操作，将“ll”替换为“r”。这同String类的Replace方法非常类似，其常用形式包括：publicStringBuilder

Replace(char

oldChar,charnewChar);publicStringBuilder

Replace(string

oldValue,stringnewValue);其中，参数oldChar和oldValue为待替换的字符和子串，而newChar和newValue为替换后的新字符和新子串。2023/2/456C#程序设计实用教程

7.1.2动态字符串StringBuilder

下例把“Hello”通过替换为“Hero”。//ReplaceStringBuildersb8=newStringBuilder("Hello");sb8=sb8.Replace("ll","r"); Console.WriteLine(sb8); //Hero2023/2/457C#程序设计实用教程

7.1.2动态字符串StringBuilder

7.与String比较可以看出StringBuilder与String在许多操作上是非常相似的。而在操作性能和内存效率方面，StringBuilder要比String好得多。而另一方面，String类提供了更多的方法，可以使开发能够更快地实现应用。在两者的选择上，如果应用对于系统性能、内存要求比较严格，以及经常处理大规模的字符串，推荐使用StringBuilder对象；否则，可以选择使用String。2023/2/458C#程序设计实用教程

7.2数组

数组的作用非常强大，数据也是基本数据结构之一，是编程实现过程中必不可少的要素之一。2023/2/460C#程序设计实用教程

7.2.1数组的概念

数组（Array）是一种数据结构，一个数组由若干个类型相同的数组元素的变量，这些变量可以通过一个数组名和数组下标（或者称为索引）来访问。C#中的数组下标是从零开始，数组中的所在元素都具有相同的类型。在数组中，每一个成员叫做数组元素，数组元素的类型称为数组类型，数组类型可以是C#中定义的任意类型，其中也包括数组类型本身。如果一个数组的类型不是数组类型，称之为一维数组。如果数组元素的类型是数组类型，就称之为多维数组，也就是说，数组定义可以嵌套。2023/2/461C#程序设计实用教程

7.2.1数组的概念

无论是一维数组还是多维数组，每个维的下标都是从0开始，结束于这个维的数组长度减1。数组被用于各种目的，因为它提供了一种高效、方便的手段将相同类型的变量合成一组。例如，可以用数组保存一个月中每天的温度记录，货物平均价格的记录。数组的主要优点是，通过这样的一种方式组织数据使得数据容易被操纵。例如，有一个数组，它包括选定的一组学生的数学成绩，操作该数组，很容易计算其平均数学成绩。而且数据以这样的方式组织数据，会很容易实现对数据的排序。2023/2/462C#程序设计实用教程

7.2.1数组的概念

在实际使用数据的过程中，一般是先确定数据类型，然后根据实际情况确定数组的长度。C#中的数组是由System.Array类派生而来的引用对象，因此可以使用Array类的方法来进行各种操作。另外，数组常常用来实现静态的操作，即不改变其空间大小，如查找、遍历等。数组也可以实现动态的操作、如插入、删除等，但不推荐使用，而应尽量使用集合来代替。2023/2/463C#程序设计实用教程

7.2.2System.Array类

System.Array类是C#中各种数组的基类，其常用属性和方法的简单说明如表7-1所示。2023/2/464C#程序设计实用教程

7.2.3一维数组

由具有一个下标的数组元素所构成的数组就是一维数组，一维数组是简单的数组。例如：为了记录50个银行储蓄用户的账号，就可以使用一个长度为50的一维数组来处理。一维数组比较直观，使用起来相对容易。2023/2/465C#程序设计实用教程

7.2.3一维数组

1.一维数组的定义数据在使用前使用先进行定义。定义一维数组的格式如下：

数据类型[]数组名：其中数组类型为各种数据类型，它表示数据元素的类型；数组名可以是C#合法的标识符；在数组名与数据类型之间是一组空的方括号。例如：char[]charArr;//定义了一个字符型的一维数组int[]intArr;//定义了一个整型一维数组string[]strArr;//定义了一个字符串类型一维数组在定义数组后，必须对其进行初始化才能使用；初始化数组有两种方法，即动态初始化和静态初始化。2023/2/466C#程序设计实用教程

7.2.3一维数组

2.动态初始化动态初始化需要借助new运算符，为数组元素分配内存空间，并为数据元素赋初始值。动态初始化数组的格式如下：

数组名=new数据类型[数组长度]；在C#中，可以将数组定义与动态初始化合在一起，格式如下：

数据类型[]数组名=new数据类型[数组长度]；2023/2/467C#程序设计实用教程

7.2.3一维数组

例如：

int[]intArr=newint[5];上面的语句定义了一个整型数组，它包含从intArr[0]到intArr[4]这5个元素。New运算符用于创建数组，并用默认值对数据元素进行初始化。在本例中，所有数组元素的值都被初始化为0。当然，用户也可以为其赋予初始化值，程序代码如下：

int[]intArr=newint[5]{3,6,9,2,10};此时数组元素的初始化值就是大括号中列出的元素值。2023/2/468C#程序设计实用教程

7.2.3一维数组

定义其他类型的数组的方法是一样的，如下面的语句用于定义一个存储10个字符串元素的数组，并对其进行初始化： string[]strArr=newstring[10];在本例中，strArr数组中所有数组元素的初始值都为“”。2023/2/469C#程序设计实用教程

7.2.3一维数组

3.静态初始化静态初始化数组时，必须与数组定义结合在一起，否则程序就会报错。静态初始化数组的格式如下：

数据类型[]数据名={元素1[,元素2…]};用这种方法对数组进行初始化时，无须说明数组元素的个数，只需按顺序列出数组中的全部元素即可，系统会自动计算并分配数组所需的内存空间。例如：int[]intArr={3,6,9,2,10};string[]strArr={“English”,”Maths”,”Computer”,”Chinese”};2023/2/470C#程序设计实用教程

7.2.3一维数组

4.关于一维数据初始化的几点说明（1）动态初始化数组时，可以把定义与初始化分开在不同的语句中者，例如：int[]intArr;//定义数组intArr=newint[5];//动态初始化，初始化元素的值均为0或者intArr=newint[5]{3,6,9,2,10};此时，在newint[5]{3,6,9,2,10}这条语句中，方括号中表示数组元素个数的“５”可以省略，因为后面大括号中已列出了数组中的全部元素。2023/2/471C#程序设计实用教程

7.2.3一维数组

4.关于一维数据初始化的几点说明（2）静态初始化数组必须与数组结合在一条语句中，否则程序就会出错。（3）在数组初始化语句中，如果大括号中已明确列出了数组中的元素，即确定了元素个数，则表示数组元素个数的数值（即方括号中的数值）必须是常量，并且该数值必须与数组元素个数一致。2023/2/472C#程序设计实用教程

7.2.3一维数组

5.访问一维数组中的元素在C#中是通过数组名和下标值来访问数组元素的。在访问数组元素时，其下标可以是一个整型常量或整型表达式。例如，下面的数组元素的下标都是合法的：

intArr[3]，strArr[0]，intArr[j]，strArr[2*i-1]在实际的程序设计中，也可能导致下标值超越正常取值范围。如果下标越界，将会抛出一个System.IndexOutOfRangeException的异常。2023/2/473C#程序设计实用教程

7.2.3一维数组

【例7-1】给定8个数：8、7、6、5、4、3、2、1，将这些数存在数组中，并将其按从小到大的顺序输出。（1）定义一个数组，如数组名为QueArrey，并将其用给定的数进行初始化。（2）遍历数组，将8个数中最小的数找出来，与第１个位置上的数对调。其方法是：先找出存放最小的数组元素的下标，将其存放在变量temp中，然后将QueArray[0]和QueArray[temp]中的数对调，使QueArray[0]中存放的是８个数中最小的数。（3）再从第２个数到第８个数中找出最小的数，并按步骤（2）中的方法，将最小的数与第２个位置上的数对调，使QueArray[1]中存放的是第2小的数。（4）依次类推，完成整个排序过程，并输出结果。2023/2/474C#程序设计实用教程

7.2.3一维数组

程序代码如下：usingSystem;

namespaceArraySort{classArraySort{staticvoidMain(){

inti,j,temp,m;

int[]QueArray=newint[]{8,7,6,5,4,3,2,1};for(j=0;j<QueArray.Length;j++){temp=j;2023/2/475C#程序设计实用教程

7.2.3一维数组

for(i=j+1;i<QueArray.Length;i++)//从j的下一个元素起开始比较{

if(QueArray[i]<QueArray[temp])

//比较数组元素temp=i;

//使temp为较小的数的下标}

if(temp!=j){/*交换QueArray[temp]和QueArray[j]的值，

从而可以从所比较的数组元素中获得较小

的娄赋给QueArray[j]*/m=QueArray[j];

QueArray[j]=QueArray[temp];

QueArray[temp]=m;}}2023/2/476C#程序设计实用教程

7.2.3一维数组

Console.WriteLine("输出排序后的结果：");

for(j=0;j<QueArray.Length;j++)Console.Write("{0}",QueArray[j]);}}}执行该程序后，程序输出结果如下：123456782023/2/477C#程序设计实用教程

7.2.3一维数组

注意：（1）除了可以显式地指出数组长度之外，更好的做法是使用System.Array类的Length属性，数组的Length用于获取数组所包含的全部元素的个数。（2）上面所用的排序方法是一种常规的方法，在C#中，对数组进行排序还有更高效的方法；可以使用Array类的Sort方法完成这个功能。Sort方法有多种的重载方法，常用的形式如下： publicstaticvoidSort(Arrayarray);2023/2/478C#程序设计实用教程

7.2.3一维数组

【例7-2】给定8个数：8、7、6、5、4、3、2、1，将这些数存在数组中，利用Array类的Sort方法将其按从小到大的顺序输出。usingSystem;

namespaceSortArray{classSortArray{staticvoidMain(){

int[]QueArray=newint[]{8,7,6,5,4,3,2,1};//定义数组

//输出原始数组

Console.WriteLine("原始数组：");

for(inti=0;i<QueArray.Length;i++)Console.Write("{0}->",QueArray[i]);

Console.WriteLine();//进行换行

Array.Sort(QueArray);//对数组排序

//输出排序后的数组

Console.WriteLine("排序以后的数组：");for(inti=0;i<QueArray.Length;i++)Console.Write("{0}->",QueArray[i]);}}}2023/2/479C#程序设计实用教程

7.2.3一维数组

for(inti=0;i<QueArray.Length;i++)Console.Write("{0}->",QueArray[i]);

Console.WriteLine();//进行换行

Array.Sort(QueArray);//对数组排序

//输出排序后的数组

Console.WriteLine("排序以后的数组：");for(inti=0;i<QueArray.Length;i++)Console.Write("{0}->",QueArray[i]);}}}2023/2/480C#程序设计实用教程

7.2.3一维数组

6.查找元素在数组中查找元素，一是从整个数组中寻找到与给定值相同的元素来，可以使用Array类的BinarySearch方法完成这个功能。二是判定数组中是否含有一个特定的元素，可以用Contains方法来实现。（1）BinarySearch方法BinarySearch使用二进制搜索算法在一维的排序Array中搜索算法，注意必须是已经排序的数组。如果找到给定的值，则返回其下标；否则，返回一个负整数。常用形式如下： publicstaticint

BinarySearch(Array

array,objectvalue);其中，参数array为待搜索的数组，value为待寻找的元素值。2023/2/481C#程序设计实用教程

7.2.3一维数组

【例7-3】给定8个数：8、7、6、5、4、3、2、1，将这些数存在数组中，利用Array类的BinarySearch方法返回其中的元素5的下标。usingSystem;

namespaceBinarySearch{classBinarySearch{staticvoidMain(){//定义数组

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

//对数组排序

Array.Sort(myArr);

2023/2/482C#程序设计实用教程

7.2.3一维数组

//搜索

inttarget=5;

intresult=Array.BinarySearch(myArr,target);//4Console.WriteLine("{0}的下标为{1}",target,result);//4

Console.ReadLine();}}}2023/2/483C#程序设计实用教程

7.2.3一维数组

（2）Contains方法Contains方法可以确定某个特定值的否包含在数组中，返回一个bool值。Array类的这个方法实际上是对IList接口中方法的实现，常用形式如下：bool

IList.Contains(objectvalue);其中，参数value代表所要验证的元素值。2023/2/484C#程序设计实用教程

7.2.3一维数组

【例7-4】判定学生数组arrSname中是否包含“赵六”。usingSystem;

namespaceContains{classContains{staticvoidMain(){//定义数组string[]arrSname={"大宝","张三","李四","赵六","赵二","麻子"};

2023/2/485C#程序设计实用教程

7.2.3一维数组

//判定是否含有某值stringtarget="赵六";

boolresult=

((System.Collections.IList)arrSname).Contains(target);

Console.WriteLine("包含{0}?{1}",target,result);//True}}}2023/2/486C#程序设计实用教程

7.2.3一维数组

7.把数组作为参数将数组作为参数传递可以将初始化的数组传递给方法。例如：int[]myArray=newint[]{1,3,5,7,9};PrintArray(myArray);也可以直接将一个初始化过的数组作为参数进行传递。例如下面的代码等价于上面数组传递。PrintArray(newint[]{1,3,5,7,9});2023/2/487C#程序设计实用教程

7.2.3一维数组

【例7-5】演示把一个初始化后字符串数组作为参数传递给PrintArray方法。usingSystem;

namespaceParameter{classParameter{staticvoidPrintArray(string[]strArr){for(inti=0;i<strArr.Length;i++)Console.Write("{0}",strArr[i]);

Console.WriteLine();}2023/2/488C#程序设计实用教程

7.2.3一维数组

staticvoidMain(){string[]WeekDays=newstring[]{"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

PrintArray(WeekDays);//把数组作为参数}}}在上面的例子中，主函数Main把定义好的数组WeekDays作为参数传递给方法PrintArray，PrintArray方法把接收到的数组元素一个个地打印出来。2023/2/489C#程序设计实用教程

7.2.4二维数组

在C#中，多维数组可看作是数组的数组，即高维数组。多维数组中的每一个元素本身也是一个低维数组，因此多维数组的定义、初始化和元素访问与一维数组都非常相似。在多维数组中，二维数组是最简单也是最常用的数组，本节主要介绍二维数组。2023/2/490C#程序设计实用教程

7.2.4二维数组

１.二维数组的定义二维数组的一般语法格式如下：

数据类型[,]数组名其中数据类型为数组中元素的类型，可以是前面定义的各种数据类型；数组名可以是C#中合法的标识符；数组的每一维是用逗号隔开的。例如：char[,]charArr;//定义一个字符型二维数组int[,]intArr;//定义一个整型二维数组2023/2/491C#程序设计实用教程

7.2.4二维数组

定义多维数组与二维数组的方法相同，只是要根据定义数组的维数确定方括号中的逗号的个数，一般定义一个n(n≥2)维数组，需要的逗号个数是n-1。例如，下面语句定义的是一个三维数组： String[,,]stringArr;//定义一个字符串型三维数组2023/2/492C#程序设计实用教程

7.2.4二维数组

2.二维数组的初始化二维数组包括两种初始化方法，即：动态初始化和静态初始化。动态初始化二维数组的格式如下：

数组名=new数据类型[数组长度１,数组长度2];其中，数组长度1和数组长度2可以是整型的常量或变量，它们分别表示数组第一维和第二维的长度。2023/2/493C#程序设计实用教程

7.2.4二维数组

也可以将二维数组的定义与动态初始化合并在一条语句中，格式如下：

数据类型[,]数组名=new数据类型[数组长度１,数组长度2];例如：

int[,]intArr=newint[3,2];上例中new运算符用于创建数组，并默认对数组元素进行初始化。在上例中，所有数组元素的值都被初始化为0。2023/2/494C#程序设计实用教程

7.2.4二维数组

上面的语句定义一个二维数组，其中第１维的长度为3，第2维的长度为2。在二维数组中，第1维常常称为行，第2维也称为列。这样，一个二维数组就同一个二维表格相对应起来了。可以这样理解二维数组：如果只给出二维数组的第1维下标，以一维数组来看二维数组，则这样的数组中所代表的是另一个一维数组。2023/2/495C#程序设计实用教程

7.2.4二维数组

在动态初始化二维数组时，也可以直接为其赋予初始化值，如下所示：

int[,]intArr=newint[,]{{1,2},{3,4},{5,6}};它表示的数组元素的值如表7-2所示。2023/2/496C#程序设计实用教程

7.2.4二维数组

二维数组可以进行静态初始化。例如，下面的语句定义一个2行3列的double类型二维数组，并对其进行静态初始化。 double[,]doubleArr={{1.2,2.3,3.4},{4.5,5.6,6.7}};静态初始化二维数组时，也必须与数组定义结合在一条语句中，否则程序就会报错。而动态初始化数组时，它们可以分开在不同的语句中。2023/2/497C#程序设计实用教程

7.2.4二维数组

3.访问二维数组的元素二维数组也是通过数组名和下标值来访问数组元素的，二维数组的下标值也是从0开始的。与一维数组不同的是，二维数组需要两个下标才能唯一标识一个数组元素，其中第１个下标该元素所在的行，第2个下标表示该元素所在的列。如intArr[2,0]代表数组名为intArr的二维数组中位于第3行、第1列的元素。根据二维数组的特点，访问二维数组中的元素通常需要一个二重循环。2023/2/498C#程序设计实用教程

7.2.4二维数组

【例7-6】通过二重循环，将1到16的数赋给二维数组，然后显示数组的内容。程序代码如下：usingSystem;

namespaceTwoArr{classTwoArr{staticvoidMain(){

inti,j;2023/2/499C#程序设计实用教程

7.2.4二维数组