C#入门到入土(二)

橘子喵
160 阅读5分钟

9、复杂数据类型

一、枚举

  1. 在namespace中声明

  2. 声明枚举 --> 创建一种类型

    enum E_PlayerStates
{
    idle = 0;
    walk;
    run;
    jump;
    swimming;
}
//默认的枚举值是从0开始自动赋值，若中途有赋值为i，后续赋值则为i+1

  3. 声明枚举变量 （创建一个自定义枚举类型的变量）

    E_PlayerStates playerStates = E_playerStats.idle;

  4. 枚举的类型转换

    1. 枚举与 int 互转——()强转
      //枚举转换为int，值为定义时的具体指，默认从0递加
int i = (int)playerStates;

//int转枚举，只能赋予枚举范围内的值
playerStates = 0;
    2. 枚举与string互转
      • Enum.Parse()方法
      • 对象.toString()方法
      f//枚举转string，调用toString方法，值为声明枚举时的字符串值
string str = playerStates.toString();

//string转枚举
playerStates = (E_PlayerStates)Enum.Parse(typeof(playerStates),"idle")
//此处最后Parse函数返回的是一个Object类型的数据，所以最后需要用括号转换成需要的类型

  5. 枚举的作用

    • 枚举在常用在表示各种状态，开发中经常和 Switch 配套使用，枚举的作用主要就是增强代码可读性
    enum E_PlayerStates
{
    idle;
    walk;
    run;
    jump;
    swimming;
}

E_PlayerStates playerStates = idle;

Switch (playerStates)
{
    case playerStates.idle:
        {//XXXXXX}
        break;
    case playerStates.walk:
        {//XXXXXX}
        break;
}

二、数组

  • 一维数组：arr[r]
  • 二维数组：arr[r][c]
  • 下标索引从 0 开始计数

1. 一维数组

  1. 一维数组的声明

    //1.声明数组，必须在之后初始化
int[] arr0;

//2.声明长度为5，未初始化
int[] arr1 = new int[5];

//3.声明长度为5，并且为其初始化，后大括号中的数据必须和长度相等
int[] arr2 = new int[5]{0, 1, 2, 3, 4, 5};

//4.声明长度为大括号中数据个数的数组，为其初始化
int[] arr3 = new int[]{1, 2, 3, 4, 5};

//5.声明长度为大括号中数据个数的数组，并为其初始化
int[] arr3 = {1, 2, 3, 4, 5};

  2. 一维数组的使用

    1. 通过下标获取元素

      //注意下标不能越界 下标从0 ~ n-1
int i = arr[1];

    2. 修改指定元素

      arr[0] = 123;

    3. 获取数组长度

      int length = arr.Length;

    4. 遍历数组

      for(int i = 0;i < arr.Length ; i++)
{
    Console.WriteLine(arr[i]);
}

    5. 增加数组元素

      //给arr[5]扩容成arr[6]
int arr1[] = new int[6];
for (int i = 0; i < arr.Length; i++)
{
    arr1[i] = arr[i];
}
//最后将数组指针指向新数组，arr1会被gc机制自动回收
arr = arr1;

    6. 删除数组元素

      //删除arr[5]的最后一个元素
int arr2[] = new int[4];
for (int i = 0; i < arr2.Length; i++)
{
    arr2[i] = arr[i];
}

    7. 查找数组元素

      //查找下标为3的元素值
for(int i = 0;i < arr.Length ; i++)
{
    if(i == 3) 
    Console.WriteLine(arr[i]);
}

二维数组

  1. 二维数组的声明（N 维）

    //变量类型[,] 二维数组变量名;
int[,] arr; //申明过后 会在后面进行初始化

//变量类型[,] 二维数组变量名 = new 变量类型[行,列];
int[,] arr2 = new int[3, 3];

//变量类型[,] 二维数组变量名 = new 变量类型[行,列]{ {0行内容1, 0行内容2, 0行内容3.......}, {1行内容1, 1行内容2, 1行内容3.......}.... };
int[,] arr3 = new int[3, 3] { { 1, 2, 3 }, 
                              { 4, 5, 6 }, 
                              { 7, 8, 9 } };

//变量类型[,] 二维数组变量名 = new 变量类型[,]{ {0行内容1, 0行内容2, 0行内容3.......}, {1行内容1, 1行内容2, 1行内容3.......}.... };
int[,] arr4 = new int[,] { { 1, 2, 3 },
                           { 4, 5, 6 },
                           { 7, 8, 9 } };

//变量类型[,] 二维数组变量名 = { {0行内容1, 0行内容2, 0行内容3.......}, {1行内容1, 1行内容2, 1行内容3.......}.... };
int[,] arr5 = { { 1, 2, 3 },
                { 4, 5, 6 },
                { 7, 8, 9 } };

  2. 二维数组的使用

    1. 二维数组的长度

      int [,] array = new int[2,2] {{1,1},
                              {2,2}};

//获取多少行
int row = array.GetLength(0);
//获取多少列
int cpl = array.GetLength(1);

    2. 获取二维数组的元素

      //获取第一个元素，行列下标都是从0开始计数
int i = array[0,0];

    3. 修改二维数组中的元素

      array[0, 0] = 99;

    4. 遍历二维数组

                  for (int i = 0; i < array.GetLength(0); i++)
            {
                for (int j = 0; j < array.GetLength(1); j++)
                {
                    Console.WriteLine(array[i, j]);
                }
            }

    5. 增加数组的元素

                  //将array[2, 2]扩容为array[3, 3]
            int[,] array2 = new int[3, 3];
            for (int i = 0; i < array.GetLength(0); i++)
            {
                for (int j = 0; j < array.GetLength(1); j++)
                {
                    array2[i, j] = array[i, j];
                }
            }
            //扩容完成，array指向新数组
            array = array2;

    6. 删除数组的元素

                  //将array[2, 2]缩小成为array[1, 1]
            int[,] array2 = new int[1, 1];
            for (int i = 0; i < array2.GetLength(0); i++)
            {
                for (int j = 0; j < array2.GetLength(1); j++)
                {
                    array2[i, j] = array[i, j];
                }
            }
            //扩容完成，array指向新数组
            array = array2;

  3. 交错数组

    交错数组 是 数组的数组，每个维度的数量可以不同。基本不会用

                //变量类型[][] 交错数组名;
            int[][] arr1;

            //变量类型[][] 交错数组名 = new 变量类型[行数][];
            int[][] arr2 = new int[3][];

            //变量类型[][] 交错数组名 = new 变量类型[行数][]{ 一维数组1, 一维数组2,........ };
            int[][] arr3 = new int[3][] { new int[] { 1, 2, 3 },
                                          new int[] { 1, 2 },
                                          new int[] { 1 }};

            //变量类型[][] 交错数组名 = new 变量类型[][]{ 一维数组1, 一维数组2,........ };
            int[][] arr4 = new int[][] { new int[] { 1, 2, 3 },
                                          new int[] { 1, 2 },
                                          new int[] { 1 }};

            //变量类型[][] 交错数组名 = { 一维数组1, 一维数组2,........ };
            int[][] arr5 = { new int[] { 1, 2, 3 },
                             new int[] { 1, 2 },
                             new int[] { 1 }};

                int[][] array = { new int[] { 1,2,3},
                              new int[] { 4,5} };
            //1.数组的长度
            //行
            Console.WriteLine(array.GetLength(0));
            //得到某一行的列数
            Console.WriteLine(array[0].Length);

            //2.获取交错数组中的元素
            // 注意：不要越界
            Console.WriteLine(array[0][1]);

            //3.修改交错数组中的元素
            array[0][1] = 99;
            Console.WriteLine(array[0][1]);

            //4.遍历交错数组
            for (int i = 0; i < array.GetLength(0); i++)
            {
                for (int j = 0; j < array[i].Length; j++)
                {
                    Console.Write(array[i][j] + " ");
                }
                Console.WriteLine();
            }
avatar
文章
阅读
粉丝