【C#】基础第4节——复杂数据结构

本文详细介绍了C#中的数据结构,包括常量的四种类型(整数、浮点、字符、字符串)及其定义,枚举的声明与转化,结构体的定义和特点,以及数组的声明、初始化、赋值和访问方法。此外,还探讨了多维数组、交错数组、参数数组和Array类的使用。
摘要由CSDN通过智能技术生成

1. C# 常量

常量是固定值,程序执行期间不会改变。常量可以是任何基本数据类型,比如整数常量、浮点常量、字符常量或者字符串常量,还有枚举常量。

常量可以被当作常规的变量,只是它们的值在定义后不能被修改。

1.1 整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数:0x 或 0X 表示十六进制,0 表示八进制,没有前缀则表示十进制。

整数常量也可以有后缀,可以是 U 和 L 的组合,其中,U 和 L 分别表示 unsigned 和 long。后缀可以是大写或者小写,多个后缀以任意顺序进行组合。

这里有一些整数常量的实例:

212         /* 合法 */
215u        /* 合法 */
0xFeeL      /* 合法 */
078         /* 非法:8 不是一个八进制数字 */
032UU       /* 非法:不能重复后缀 */

以下是各种类型的整数常量的实例:

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* int */
30u        /* 无符号 int */
30l        /* long */
30ul       /* 无符号 long */

1.2 浮点常量

一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。我们可以使用小数形式或者指数形式来表示浮点常量。

这里有一些浮点常量的实例:

3.14159       /* 合法 */
314159E-5L    /* 合法 */
510E          /* 非法:不完全指数 */
210f          /* 非法:没有小数或指数 */
.e55          /* 非法:缺少整数或小数 */

使用浮点形式表示时,必须包含小数点、指数或同时包含两者。使用指数形式表示时,必须包含整数部分、小数部分或同时包含两者。有符号的指数是用 e 或 E 表示的。

1.3 字符常量

字符常量是括在单引号里,例如,‘x’,且可存储在一个简单的字符类型变量中。一个字符常量可以是一个普通字符(例如 ‘x’)、一个转义序列(例如 ‘\t’)或者一个通用字符(例如 ‘\u02C0’)。

在 C# 中有一些特定的字符,当它们的前面带有反斜杠时有特殊的意义,可用于表示换行符(\n)或制表符 tab(\t)。在这里,列出一些转义序列码:

转义序列		  含义
  \\			\ 字符
  \'			' 字符
  \"			" 字符
  \?			? 字符
  \a			Alert 或 bell
  \b			退格键(Backspace)
  \f			换页符(Form feed)
  \n			换行符(Newline)
  \r			回车
  \t			水平制表符 tab
  \v			垂直制表符 tab
  \ooo			一到三位的八进制数
  \xhh . . .	一个或多个数字的十六进制数

1.4 字符串常量

字符串常量是括在双引号 "" 里,或者是括在 @"" 里。字符串常量包含的字符与字符常量相似,可以是:普通字符、转义序列和通用字符。

使用字符串常量时,可以把一个很长的行拆成多个行,可以使用空格分隔各个部分。

这里是一些字符串常量的实例。下面所列的各种形式表示相同的字符串。

string a = "hello, world";                // hello, world
string b = @"hello, world";               // hello, world
string c = "hello \t world";              // hello     world
string d = @"hello \t world";             // hello \t world
string e = "Joe said \"Hello\" to me";    // Joe said "Hello" to me
string f = @"Joe said ""Hello"" to me";   // Joe said "Hello" to me
string g = "\\\\server\\share\\file.txt"; // \\server\share\file.txt
string h = @"\\server\share\file.txt";    // \\server\share\file.txt
string i = "one\r\ntwo\r\nthree";
string j = @"one
two
three";

1.5 定义常量

常量是使用 const 关键字来定义的 。定义一个常量的语法如下:

const <data_type> <constant_name> = value;

下面的代码演示了如何在程序中定义和使用常量:

实例:

using System;

public class ConstTest
{
    class SampleClass
    {
        public int x;
        public int y;
        public const int c1 = 5;
        public const int c2 = c1 + 5;

        public SampleClass(int p1, int p2)
        {
            x = p1;
            y = p2;
        }
    }

    static void Main()
    {
        SampleClass mC = new SampleClass(11, 22);
        Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);
        Console.WriteLine("c1 = {0}, c2 = {1}",
                          SampleClass.c1, SampleClass.c2);
    }
}

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

x = 11, y = 22
c1 = 5, c2 = 10

2. C# 枚举(Enum)

枚举是一组命名整型常量。枚举类型是使用 enum 关键字声明的。

C# 枚举是值类型。换句话说,枚举包含自己的值,且不能继承或传递继承。

2.1 声明 enum 变量

声明枚举的一般语法:

enum <enum_name>
{ 
    enumeration list 
};

其中,

  • enum_name 指定枚举的类型名称。
  • enumeration list 是一个用逗号分隔的标识符列表。

枚举列表中的每个符号代表一个整数值,一个比它前面的符号大的整数值。默认情况下,第一个枚举符号的值是 0.例如:

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

下面的实例演示了枚举变量的用法:

using System;

public class EnumTest
{
    enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };

    static void Main()
    {
        int x = (int)Day.Sun;
        int y = (int)Day.Fri;
        Console.WriteLine("Sun = {0}", x);
        Console.WriteLine("Fri = {0}", y);
    }
}

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

Sun = 0
Fri = 5

注:

public:访问修饰符。公开的公共的,哪都可以访问。

enum:关键字,声明枚举的关键字

枚举名:要符合Pascal命名规范

将枚举声明到命名空间的下面,类的外面,表示这个命名空间下,所有的类都可以使用这个枚举。

枚举就是一个变量类型 ,int–double string decimal。只是枚举声明、赋值、使用的方式跟那些普通的变量类型不一样。

//枚举类型定义
public enum Gender
    {
        男,
        女
    }
    
//使用
Gender gender = Gender.男;

2.2 枚举转化

我们可以将一个枚举类型的变量跟int类型和string类型互相转换。

枚举类型默认是跟int类型相互兼容的,所以可以通过强制类型转换的语法互相转换。

//枚举类型的数字是默认从0开始的
Gender gender = Gender.男;
int n = (int)gender;//这里n是0

//有值时转换为枚举类型
//当转换一个枚举中没有的值的时候,不会抛异常,而是直接将数字显示出来。
int n1 = 2;
Gender g = (Gender)n1;

枚举同样也可以跟string类型互相转换,如果将枚举类型转换成string类型,则直接调用ToString(). 如果将字符串转换成枚举类型则需要下面这样一行代码:

(要转换的枚举类型)Enum.Parse(typeof(要转换的枚举类型),“要转换的字符串”);

如果转换的字符串是数字,则就算枚举中没有,也会不会抛异常。

如果转换的字符串是文本,如果枚举中没有,则会抛出异常。

//枚举转换为字符串
Gender gender = Gender.男;
string s = gender.ToString();//s的值为"男"


//字符串转换为枚举
string s = "0";
Gender g = (Gender)Enum.Parse(typeof(Gender),s);

3. C# 结构体(Struct)

在 C# 中,结构体是值类型数据结构。它使得一个单一变量可以存储各种数据类型的相关数据。struct 关键字用于创建结构体。

结构体是用来代表一个记录。假设我们想跟踪图书馆中书的动态。我们可能想跟踪每本书的以下属性:

  • Title
  • Author
  • Subject
  • Book ID

3.1 定义结构体

为了定义一个结构体,我们必须使用 struct 语句。struct 语句为程序定义了一个带有多个成员的新的数据类型。

例如,我们可以按照如下的方式声明 Book 结构:

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

下面的程序演示了结构的用法:

实例:

using System;
using System.Text;
     
struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1;        /* 声明 Book1,类型为 Books */
      Books Book2;        /* 声明 Book2,类型为 Books */

      /* book 1 详述 */
      Book1.title = "C Programming";
      Book1.author = "Nuha Ali";
      Book1.subject = "C Programming Tutorial";
      Book1.book_id = 6495407;

      /* book 2 详述 */
      Book2.title = "Telecom Billing";
      Book2.author = "Zara Ali";
      Book2.subject =  "Telecom Billing Tutorial";
      Book2.book_id = 6495700;

      /* 打印 Book1 信息 */
      Console.WriteLine( "Book 1 title : {0}", Book1.title);
      Console.WriteLine("Book 1 author : {0}", Book1.author);
      Console.WriteLine("Book 1 subject : {0}", Book1.subject);
      Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);

      /* 打印 Book2 信息 */
      Console.WriteLine("Book 2 title : {0}", Book2.title);
      Console.WriteLine("Book 2 author : {0}", Book2.author);
      Console.WriteLine("Book 2 subject : {0}", Book2.subject);
      Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);      

      Console.ReadKey();

   }
}

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

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

3.2 C# 结构的特点

我们已经用了一个简单的名为 Books 的结构。在 C# 中的结构与传统的 C 或 C++ 中的结构不同。C# 中的结构有以下特点:

  • 结构可带有方法、字段、索引、属性、运算符方法和事件。
  • 结构可定义构造函数,但不能定义析构函数。但是,我们不能为结构定义无参构造函数。无参构造函数(默认)是自动定义的,且不能被改变。
  • 与类不同,结构不能继承其他的结构或类。
  • 结构不能作为其他结构或类的基础结构。
  • 结构可实现一个或多个接口。
  • 结构成员不能指定为 abstract、virtual 或 protected。
  • 当我们使用 New 操作符创建一个结构对象时,会调用适当的构造函数来创建结构。与类不同,结构可以不使用 New 操作符即可被实例化。
  • 如果不使用 New 操作符,只有在所有的字段都被初始化之后,字段才被赋值,对象才被使用。

3.3 类 vs 结构

类和结构有以下几个基本的不同点:

  • 类是引用类型,结构是值类型。

  • 结构不支持继承。

  • 结构不能声明默认的构造函数。

  • 结构体中声明的字段无法赋予初值,类可以

struct test001
{
    private int aa = 1;
}

执行以上代码将出现“结构中不能实例属性或字段初始值设定”的报错,而类中无此限制,代码如下:

class test002
{
    private int aa = 1;
}
  • 结构体的构造函数中,必须为结构体所有字段赋值,类的构造函数无此限制

补充:类与结构的选择

首先明确,类的对象是存储在堆空间中,结构存储在栈中。堆空间大,但访问速度较慢,栈空间小,访问速度相对更快。故而,当我们描述一个轻量级对象的时候,结构可提高效率,成本更低。当然,这也得从需求出发,假如我们在传值的时候希望传递的是对象的引用地址而不是对象的拷贝,就应该使用类了。

针对上述讨论,让我们重写前面的实例:

using System;
using System.Text;
     
struct Books
{
   private string title;
   private string author;
   private string subject;
   private int book_id;
   public void setValues(string t, string a, string s, int id)
   {
      title = t;
      author = a;
      subject = s;
      book_id =id;
   }
   public void display()
   {
      Console.WriteLine("Title : {0}", title);
      Console.WriteLine("Author : {0}", author);
      Console.WriteLine("Subject : {0}", subject);
      Console.WriteLine("Book_id :{0}", book_id);
   }

};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1 = new Books(); /* 声明 Book1,类型为 Books */
      Books Book2 = new Books(); /* 声明 Book2,类型为 Books */

      /* book 1 详述 */
      Book1.setValues("C Programming",
      "Nuha Ali", "C Programming Tutorial",6495407);

      /* book 2 详述 */
      Book2.setValues("Telecom Billing",
      "Zara Ali", "Telecom Billing Tutorial", 6495700);

      /* 打印 Book1 信息 */
      Book1.display();

      /* 打印 Book2 信息 */
      Book2.display();

      Console.ReadKey();

   }
}

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

Title : C Programming
Author : Nuha Ali
Subject : C Programming Tutorial
Book_id : 6495407
Title : Telecom Billing
Author : Zara Ali
Subject : Telecom Billing Tutorial
Book_id : 6495700

4. C# 数组(Array)

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

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

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

C# 中的数组

4.1 声明数组

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

datatype[] arrayName;

其中,

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

例如:

double[] balance;

4.2 初始化数组

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

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

例如:

double[] balance = new double[10];

4.3 赋值给数组

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

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。

4.4 访问数组元素

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

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

4.5 使用 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

4.6 C# 多维数组

C# 支持多维数组。多维数组又称为矩形数组。

我们可以声明一个 string 变量的二维数组,如下:

string [,] names;

或者,我们可以声明一个 int 变量的三维数组,如下:

int [ , , ] m;

4.6.1 二维数组

多维数组最简单的形式是二维数组。一个二维数组,在本质上,是一个一维数组的列表。

一个二维数组可以被认为是一个带有 x 行和 y 列的表格。下面是一个二维数组,包含 3 行和 4 列:

C# 中的二维数组

因此,数组中的每个元素是使用形式为 a[ i , j ] 的元素名称来标识的,其中 a 是数组名称,i 和 j 是唯一标识 a 中每个元素的下标。

4.6.2 初始化二维数组

多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。

int [,] a = new int [3,4] {
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

4.6.3 访问二维数组元素

二维数组中的元素是通过使用下标(即数组的行索引和列索引)来访问的。例如:

int val = a[2,3];

上面的语句将获取数组中第 3 行第 4 个元素。我们可以通过上面的示意图来进行验证。让我们来看看下面的程序,我们将使用嵌套循环来处理二维数组:

using System;

namespace ArrayApplication
{
    class MyArray
    {
        static void Main(string[] args)
        {
            /* 一个带有 5 行 2 列的数组 */
            int[,] a = new int[5, 2] {{0,0}, {1,2}, {2,4}, {3,6}, {4,8} };

            int i, j;

            /* 输出数组中每个元素的值 */
            for (i = 0; i < 5; i++)
            {
                for (j = 0; j < 2; j++)
                {
                    Console.WriteLine("a[{0},{1}] = {2}", i, j, a[i,j]);
                }
            }
           Console.ReadKey();
        }
    }
}

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

a[0,0]: 0
a[0,1]: 0
a[1,0]: 1
a[1,1]: 2
a[2,0]: 2
a[2,1]: 4
a[3,0]: 3
a[3,1]: 6
a[4,0]: 4
a[4,1]: 8

注:

C# 中二维数组的概念不同于 C/C++、java 等语言中的二维数组,C# 中的二维数组更像是一个矩阵:

int [,] a = new int [3,4] {
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

这个如果是从其他语言转来学习 C# 可能会和交错数组的概念弄混。

如果将二维数组整个理解为矩阵,例如上面的理解为一个 3*4 的矩阵,那么使用的时候就更能理解 a[2,3] 这种引用方式,同时也理解了二维数组的一个性质,每一行元素都是一样的(这一点不同于交错数组)。

4.7 C# 交错数组

交错数组是数组的数组。

交错数组是一维数组。

我们可以声明一个带有 int 值的交错数组 scores,如下所示:

int [][] scores;

声明一个数组不会在内存中创建数组。创建上面的数组:

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

我们可以初始化一个交错数组,如下所示:

int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};

其中,scores 是一个由两个整型数组组成的数组 – scores[0] 是一个带有 3 个整数的数组,scores[1] 是一个带有 4 个整数的数组。

下面的实例演示了如何使用交错数组:

using System;

namespace ArrayApplication
{
    class MyArray
    {
        static void Main(string[] args)
        {
            /* 一个由 5 个整型数组组成的交错数组 */
            int[][] a = new int[][]{new int[]{0,0},new int[]{1,2},
            new int[]{2,4},new int[]{ 3, 6 }, new int[]{ 4, 8 } };

            int i, j;

            /* 输出数组中每个元素的值 */
            for (i = 0; i < 5; i++)
            {
                for (j = 0; j < 2; j++)
                {
                    Console.WriteLine("a[{0}][{1}] = {2}", i, j, a[i][j]);
                }
            }
           Console.ReadKey();
        }
    }
}

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

a[0][0] = 0
a[0][1] = 0
a[1][0] = 1
a[1][1] = 2
a[2][0] = 2
a[2][1] = 4
a[3][0] = 3
a[3][1] = 6
a[4][0] = 4
a[4][1] = 8

注:

交错数组与二维数组的区别,可以直观的理解为交错数组每一行的长度是可以不一样的。

如果说二维数组像是唐诗,那么交错数组就是宋词,每一句的长短没有限制。

// 声明一个交错数组 a,a 中有三个元素,分别是 a[0],a[1],a[2] 每个元素都是一个数组
int[][] a = new int[3][]; //这句话定义了 a 是一个数组的数组
//以下是声明交错数组的每一个元素的,每个数组的长度可以不同
a[0] = new int[] { 1,2,3 };
a[1] = new int[] { 4,5,6,7,8 };
a[2] = new int[] { 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 };

4.8 C# 传递数组给函数

在 C# 中,我们可以传递数组作为函数的参数。我们可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。

下面的实例演示了如何传递数组给函数:

using System;

namespace ArrayApplication
{
   class MyArray
   {
      double getAverage(int[] arr, int size)
      {
         int i;
         double avg;
         int sum = 0;

         for (i = 0; i < size; ++i)
         {
            sum += arr[i];
         }

         avg = (double)sum / size;
         return avg;
      }
      static void Main(string[] args)
      {
         MyArray app = new MyArray();
         /* 一个带有 5 个元素的 int 数组 */
         int [] balance = new int[]{1000, 2, 3, 17, 50};
         double avg;

         /* 传递数组的指针作为参数 */
         avg = app.getAverage(balance, 5 ) ;

         /* 输出返回值 */
         Console.WriteLine( "平均值是: {0} ", avg );
         Console.ReadKey();
      }
   }
}

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

平均值是: 214.4

4.9 C# 参数数组

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

4.9.1 params 关键字

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

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

下面的实例演示了如何使用参数数组:

using System;

namespace ArrayApplication
{
   class ParamArray
   {
      public int AddElements(params int[] arr)
      {
         int sum = 0;
         foreach (int i in arr)
         {
            sum += i;
         }
         return sum;
      }
   }
     
   class TestClass
   {
      static void Main(string[] args)
      {
         ParamArray app = new ParamArray();
         int sum = app.AddElements(512, 720, 250, 567, 889);
         Console.WriteLine("总和是: {0}", sum);
         Console.ReadKey();
      }
   }
}

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

总和是: 2938

params 用法补充:

  • 1.带 params 关键字的参数类型必须是一维数组,不能使用在多维数组上
  • 2.不允许和 ref、out 同时使用
  • 3.带 params 关键字的参数必须是最后一个参数,并且在方法声明中只允许一个 params 关键字
  • 4.不能仅使用 params 来使用重载方法
  • 5.没有 params 关键字的方法的优先级高于带有params关键字的方法的优先级

4.10 C# Array 类

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

4.10.1 Array 类的属性

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

序号属性 & 描述
1IsFixedSize 获取一个值,该值指示数组是否带有固定大小。
2IsReadOnly 获取一个值,该值指示数组是否只读。
3Length 获取一个 32 位整数,该值表示所有维度的数组中的元素总数。
4LongLength 获取一个 64 位整数,该值表示所有维度的数组中的元素总数。
5Rank 获取数组的秩(维度)。

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

4.10.2 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)继承。

如需了解 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
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值