.NET基礎——數組 - lcxBlog－IT工程師數位筆記本

文章出處

　　這一篇，我們來看C#中的數組。

1. 數組的概念

　　數組：存儲相同類型多個數據元素的容器

　　數組的聲明和初始化：在創建數組的時候，必須指定數組的長度

            int[] nums = new int[3];
            int[] nums1 = { 5,3,8 };
            int[] num2 = new int[3] { 5, 3, 8 };//數組元素的個數必須與聲明的個數一致
            //int[] nums3 = new int[5] { 5, 3, 8 }; //錯誤
            int[] nums4 = new int[] { 5, 3, 9 }; //正確，可以省略數組的個數

　　聲明了數組，但未對數組元素進行賦值，如果是int類型，則數組里面的所有元素的值都是0；如果是string類型，則數組里面所有元素的值都是null。如果你聲明了一個長度為5的int類型的數組，只想對其中的1個元素賦值，那么必須在聲明之后，對這個元素進行單獨的賦值操作。

2. 對數組的操作

　　1. 訪問數組中的元素

　　　　我們可以使用索引器來訪問指定編號位置的數組，訪問數組元素：num[0]、num[1]，索引從0開始。

　　 2. 取數組的長度

　　　　數組名.Length int len = nums.Length;

　　　　數組的長度不能被修改，若要修改，必須重新創建一個數組。

　　　　　string[] arrScore=new string[5];　　arrScore =new string[7];

　　（1） string[] arrScore=new string[5];

a)左邊：string[] arrScore，聲明數組變量時，在棧開辟空間將arrScore存入，此時為null(其實變量arrScore不存在內存，只是為了好標識)

b)右邊：new關鍵字會做四件事：開辟堆空間；創建對象；調用構造函數；返回堆空間地址。返回堆空間地址就是將地址0x16返回給等號左邊的arrScore變量，這時棧空間地址將指向堆空間地址

（2）arrScore=new string[7];

　　　　不會修改數組，而是直接創建新的數組，在堆空間開辟新的堆空間存儲，由于數組名一樣，將會覆蓋掉原先數組，即將原來的arrScore指向的堆空間地址擦除，重新指向新創建數組的地址0x20

3. 將原數組拷貝到新數組　

string[] arrScore=new string[5]{“李”，”張”，”王” ，“趙”，”孫”}；

string[] arrScoreNew=new string[7]；

a)for(int i=0;i<arr.Length;i++)

{arrScoreNew[i]=arrScore[i];}

b) arrScore.CopyTo(arrScoreNew,0);

從新數組arrScoreNew的首元素地址開始復制進去

假設：arrScore.CopyTo(arrScoreNew,2);則存儲圖如下：

　　4. 對數組進行排序

　　　典型的排序算法：冒泡排序

　　　　讓數組中的元素兩兩比較（第i個與第i+1個比較），經過n遍兩兩比較，數組中的元素能按照我們預期的規律排序。

　　　　要從大到小排序，我們進行兩兩比較的時候用 < ；反之使用 > 。

　　　　從大到小排序，如果arr[i] < ar[i+1]，則交換兩個元素的值。

　　　　 n個數需要排序n - 1趟；第t趟比較的次數為n - t次

　　　　 i=0，第一趟；i=1，第二趟；趟數：i+1

　　　　程序代碼如下：

            int[] scores = { 100, 50, 6, 7, 20, 41 };
            //進行由小到大的排序
            int length = scores.Length;
            int temp = 0;
            bool isSwap = false; //是否有交換過
            for (int i = 0; i < length; i++) //控制比較的趟數，循環一次表示比較一趟
            {
                isSwap = false;
                //控制每一趟比較的次數，第x趟需要比較n-x次
                for (int j = 0; j < length - i -1; j++)
                {
                    if (scores[j] > scores[j + 1])//如果這里把j寫成i的話，這樣每一趟比較都是兩個固定的數
                    {
                        temp = scores[j];
                        scores[j] = scores[j + 1];
                        scores[j + 1] = temp;
                        isSwap = true;
                    }
                }
                if (isSwap == false) //如果在某一趟排序沒有進行交換，則數組已經是有序的了，沒有必要進行排序
                {
                    break;
                }
            }

5. 調用已有方法對數組排序

　　上面的冒泡排序算法一般會在面試中考到，但在程序中我們可以通過靜態方法對數組進行排序。

　　Array.Sort(array); 　　 //對數組進行升序排列

　　Array.Reverse(array); //對數組進行反轉，這樣就達到了對數組進行降序排列的效果

6. 求出數組中的最大值和最小值3

　　1）通常采用的方法

int max = arr[0];
for(int i = 1; i < arr.Length ;i++)
{
    if ( arr[i] > max  )
    {
           max = arr[i];
    }
}

int min = arr[0];
for(int i = 1; i < arr.Length ;i++)
{
    if ( arr[i] <  min )
    {
           min = arr[i];
    }
}

　　當循環結束的時候，就可以獲得數組中的最大值/最小值了。

　　2）數據需要從字符串中解析出來的時候

            string[] lines = File.ReadAllLines("1.txt", Encoding.Default);
            //max設置為int類型能夠表示的最小值；min設置為int類型能夠表示的最大值
            int max = int.MinValue;
            int min = int.MaxValue;
            int sum = 0;
            for (int i = 0; i < lines.Length; i++)
            {
                string[] items = lines[i].Split(new char[] {','},StringSplitOptions.RemoveEmptyEntries);
                int sar = Convert.ToInt32(items[1]);
                sum += sar;
                if (max < sar)
                {
                    max = sar;
                }
                if (min > sar)
                {
                    min = sar;
                }
            }
            Console.WriteLine("這些員工的最高工資{0}，最低工資{1}，平均工資{2}", max, min, sum / lines.Length);
            Console.ReadKey();