C#学习笔记（七）数组的基本用法

第十二章 数组

1. 一维数组、矩形数组和交错数组的基本使用

//一维数组、矩形数组以及交错数组的基本用法
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System;

namespace test19
{
    class Program
    {
        static void Main(string[] args)
        {
            //等号的左边是数组声明，右边是实例化，使用new运算符
            int[] arr1 = new int[6];   //实例化带有六个元素的一维数组
            int[,] arr2 = new int[3,5];  //实例化一个二维矩形数组，逗号的个数加1表示数组的维度;矩形数组，不管多少维度，只用一个方括号;每个子数组长度相同
            int[][,] arr3 = new int[3][,];  //实例化一个*数组，它带有三个二维数组的交错数组，交错数组的位数取决于方括号的个数

            //访问数组元素，使用整数索引访问
            //数组在实例化后，若没有初始化，则赋予所对应类型的默认值，整型是0，浮点型是0.0，bool型是false，引用类型是null
            Console.WriteLine("......................");
            Console.WriteLine("一维数组显示如下：");
             for(int i = 0;i<6;i++)
             {
                 arr1[i] = i*6;
                 Console.WriteLine("arr1[{0}]={1}",i,arr1[i]);
             }
            Console.WriteLine("......................");
            Console.WriteLine("矩形数组显示如下：");
            for(int i = 0;i<3;i++)
            {
               for(int j=0;j<5;j++)
               {
                   arr2[i,j] = i*5+j;
                   Console.WriteLine("arr2[{0},{1}] = {2}",i,j,arr2[i,j]);
               }
            }
            Console.WriteLine("......................");
            Console.WriteLine("交错数组显示如下：");
            //交错数组的初始化不能一步到位，首先实例化一个*数组；然后为每一个子数组都创建一个新的数组
            arr3[0] = new int[,]{{10,20},{30,40}};  //创建子数组的格式
            arr3[1] = new int[,]{{6,66},{5,55},{8,88}};
            arr3[2] = new int[,]{{12,15},{16,17},{16,81},{15,25}};
            
             for(int i = 0;i<arr3.GetLength(0);i++)
            {
               for(int j=0;j < arr3[i].GetLength(0);j++)
               {
                   for(int k =0;k<arr3[i].GetLength(1);k++)
                   {
                       arr2[i,j] = i*5+j;
                       Console.WriteLine("arr2[{0},{1}] = {2}",i,j,arr2[i,j]);
                   }
                Console.WriteLine(" ");
               }
             Console.WriteLine(" ");
            }
        }
    }
}

执行结果如下：

2. 交错数组：

//交错数组的基本使用：交错数组的每一个子数组又是一个数组
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace test18
{
    class Program
    {
        static void Main(string[] args)
        {
             int[][,] arr = new int[3][,];  //先实例化一个*数组，带有三个二维数组的交错数组  
             arr[0] = new int[,] {{10,20},{30,40}};    //为每一个子数组创建一个新的数组
             arr[1] = new int[,] {{50,60},{70,80},{90,100}};    
             arr[2] = new int[,] {{110,120},{130,140},{150,160},{170,180}};   

             //显示数组中的每一个元素
             for(int i = 0;i<arr.GetLength(0);i++)
             {
                 for(int j =0;j<arr[i].GetLength(0);j++)
                 {
                     for(int k=0;k<arr[i].GetLength(1);k++)
                     Console.WriteLine("arr[{0}][{1},{2}] = {3}",i,j,k,arr[i][j,k]);
                 }
                 Console.WriteLine(" ");
             }  
            Console.WriteLine(" ");  
        }
    }
}

执行结果：

3. foreach语句在数组中的运用：

//数组中的foreach语句
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace test20
{
    class Program
    {
        public class Myclass
        {
            public int initialvalue = 0;
        }
        static void Main(string[] args)
        {
            //在一维数组中使用foreach
            Console.WriteLine("在值类型数组中使用foreach");
            int[] arry1 = new int[6];   //实例化一维数组
            for(int i = 0;i<6;i++)
            {arry1[i] = i*6+1;}
            foreach(int item in arry1)     //迭代变量存储值类型数组的元素数据，由于迭代变量是只读的，固不可改变
            {
                Console.WriteLine(item);
            }

            Console.WriteLine("在引用类型数组中使用foreach");
            Myclass[] mycl = new Myclass[3];  //实例化带有三个类元素的数组
            mycl[0] = new Myclass();
            mycl[1] = new Myclass();
            mycl[2] = new Myclass();
            mycl[0].initialvalue = 16;
            mycl[1].initialvalue = 18;
            mycl[2].initialvalue = 20;
            foreach(Myclass myc in mycl)  //迭代变量存储的是数组元素的引用，引用不可改变，但是引用对象的数据是可以修改的
            {
                Console.WriteLine(myc.initialvalue+10);
            }
            
            Console.WriteLine("...........................");

           //在矩形数组中使用foreach
            Console.WriteLine("在矩形数组中使用foreach");
            int[,] arry2 = new int[2,4];  //实例化矩形数组
            for(int i = 0;i<arry2.GetLength(0);i++)
            {
                for(int j = 0;j<arry2.GetLength(1);j++)
                {arry2[i,j] = i*6+j;}
            }

            foreach(int item in arry2)
            {
                Console.WriteLine(item);   
            }
            Console.WriteLine("...........................");
            Console.WriteLine("在交错数组中使用foreach");
            int[][,] arry3 = new int[3][,];  //实例化带有三个二维矩形数组的交错数组
            arry3[0] = new int[,]{{1,2},{3,5}};  //为每一个子数组创建一个新的数组
            arry3[1] = new int[,]{{6,8},{9,12},{13,25}};
            arry3[2] = new int[,]{{36,39},{35,56},{64,81},{96,36}};

            foreach(int[,] item in arry3)  //arry3的每一个子数组都是一个矩形数组，先访问*数组
            {
                foreach(int i in item)  //处理子数组的每一项，难道只能单独的把所有元素给打印出来？
                {
                    Console.WriteLine(i);
                }
            }
        }
    }
}

执行结果：

4. **数组协变 **：在某些情况下，可以将不属于数组基类型的对象赋值给数组，这时，要求数组是引用类型数组，将对象赋值给数组成员存在隐式或者显示转换。比如把派生类的对象赋值给基类的成员这是允许的，本质上还是数据类型转换作用在数组上的结果。

5. 数组继承于System.Array类，继承的属性和方法有：
   （1）Rank属性：返回数组的维度

   （2）GetLength方法：返回某一维度元素的个数

   （3）Length属性：返回数组所有元素的个数

   （4）Clear方法：将某一范围内的元素设为0或者null

   （5）Sort方法：在一维数组中对元素进行排序

   （6）BinarySearch方法：在一维数组中使用二进制搜索值

   （7）Clone方法：对数组浅复制，对值类型或引用类型都只复制元素

   （8）IndexOf方法：返回一维数组中遇到的第一个数

   （9）Reverse方法：反转一维数组中某一范围内的元素

   （10）GetUpperBound方法：获取指定维度的上限。

6. **Clone方法：**对于值类型的数组，得到两个独立的数组，元素的值相同，但是存储在不同的内存位置；对于引用类型，得到两个指向相同对象的数组，对其中某一个数组做出修改，也会反映到另一个数组上面；Clone方法返回Object类型的引用，需要强制类型转换为数组类型。

int[] arry1 = {1,2,3};
int[] arry2 = (int[]) arry1.Clone();   //强制转换为数组类型