使用時機

當需要使用到大量的記憶空間時, 陣列即是一項選擇. 比如, 想要記錄10個學生的成績, 在前述的方法中, 只能使用 int s1, s2, s3……一直寫到s10.

那如果有100個學生呢, 不就寫到手骨折了.

陣列宣告與建立

陣列為物件(參考型別), 需使用new產生. 如

int [] score;//宣告
score=new int[10];//產生10個空間

以上, 可合伴為
int[] score=new int[10];

請注意 : int score[] 是錯誤的

陣列元素使用

要將陣列裏的10個數字取出列印, 可以使用如下方法.

其中score[i] 的 “i”, 稱為索引(index), 其值為 0~9, 不可超出9, 否則就是超出邊界(Out of Boundle)

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

二維陣列

假如想要記錄10個學生的國英數三科成績, 此時就需使用二維陣列, 先看下面程式碼

static void Main(string[] args)
{
	int[,] student = new int[10,3];
	for (int i = 0; i < student.GetLength(0); i++)
	{
		for (int j = 0; j < student.GetLength(1); j++)
		{
			Console.Write("{0} ", student[i, j]);
		}
		Console.WriteLine();
	}
}

int[,] student=new int[10,3]; 最表示宣告10列, 3行的二維陣列. 陣列維度可以最多達到32維.

存取二維陣列, 則需使用巢狀迴圈. GetLength(0) 是取得第一維(列)的長度, GetLength(1)是取得第二維(行)的長度

二維陣列的座標

二維陣列的標示, 前面的數字為列, 後面的數字為行, 這跟數學的xy座標剛好相反. 底下是每一格的座標

array

陣列變數初始化

陣列變數若未初始化, 則無法使用, 如下

int[] s;

此時只知道s是一個變數, 而且這個變數是一個陣列, 陣列裏面存放的是整數. 但有幾個空間呢, 因為還沒初始化, 所以不知道, 當然也不能用.

s=new int[10]
s[0]=100

當 new int[10]之後, 就產生10個空間, 此時才可以使用

陣列元素初始化

當產生出10個空間後, 那這10個空間的值是多少呢. 這種元素未初始化的狀況下, 系統會自動將這10個空間全部歸 0

另外也可以在宣告時就給予初始值

int []s=new int[]{1,2,3,4,5};
也可以簡化成如下
int []s={1,2,3,4,5}

二維陣列的初始值

int [,] s=new int[,]{{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}
也通以寫成
int [,] s=new int[3,5]{{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}, 不過這種方法是多此一舉, 因為系統會自動幫我們算行及列的數目

陣列常用的屬性與方法

Length : 屬性, 查陣列總長度

Rank : 屬性, 查陣列維度

GetLength(0) : 方法, 取得某一維度之長度

int[,]a=new int[,]{3,4};
a[0].Length, 此法在Java為正確的寫法, 但在 C#是錯誤的寫法

foreach

foreach適用於集合之迴圈

foreach(資料型別 var in 集合物件){}, 請參照如下代碼

static void Main(string[] args)
{
    int[] s = { 1, 2, 3, 4, 5 };
    foreach (int i in s)
    {
        Console.WriteLine(i);
    }
}

Array.ForEach()用法

先產生一個Action物件, 此物件指明了要執行的方法. 然後使用
Array.ForEach(陣列, action), 將陣列及action傳入, 此時就會依陣列的元素, 一個一個執行Action的工作.

底下代碼, 是計算 1-5的圓面積

class Program
{
	static void Main(string[] args)
	{
		int[] r = { 1, 2, 3, 4, 5 };
		Action myAction = new Action(Area);
		Array.ForEach(r, myAction);
	}
	static void Area(int r)
	{
		Console.WriteLine(r*r*Math.PI);
	}
}
結果
3.14159265358979
12.5663706143592
28.2743338823081
50.2654824574367
78.5398163397448

陣列的排序與搜尋

Array.Sort(Array1, Array2) : 可只有一個Array, 最多二個

Array.Reverse(Array);

不等長陣列

等長陣列又稱矩陣，二維，三維皆是

不等長陣列則每列長度皆不一樣, 也就是陣列中又可以存放陣列, 宣告及使用方法如下

static void Main(string[] args)
{
	int[][] a = new int[3][];
	a[0] = new int[5];
	a[1] = new int[3];
	a[2] = new int[6];
	for (int i = 0; i < a.Length; i++)
	{
		for (int j = 0; j < a[i].Length; j++)
		{
			Console.Write("{0} ", a[i][j]);
		}
		Console.WriteLine();
	}
}

以上在存取陣列時, 是使用二個中括號, 也就是 [列][行]來標示陣列的座標. 另外總共列數是使用 a.Length, 而每一列的長度, 就可以使 a[i].Length. 請注意一下, Length後面沒有 ()

struct 結構

C#也有跟C語言一樣的struct, 使用方式如下

namespace ConsoleApp1
{
    class Program
    {
        struct Student
        {
            public string name;
            public int chinese;
            public int math;
        }
        static void Main(string[] args)
        {
            Student s1=new Student();
            s1.name = "Thomas";
            s1.chinese = 100;
            Console.WriteLine("{0},{1}", s1.name, s1.chinese);
        }
    }
}

struct需要寫於Main()之外, 而且裏面的變數都必需宣告為 public才可以讀取.

陣列的形態, 也可以是struct , 如下

namespace ConsoleApp1
{
    class Program
    {
        struct Student
        {
            public string name;
            public int chinese;
            public int math;
        }
        static void Main(string[] args)
        {
            Student[] bcc = new Student[] {
                new Student(){name="Thomas", chinese=100, math=100 },
                new Student(){name="Jonh", chinese=70, math=50 },
                new Student(){name="Tom", chinese=80, math=100 }
            };
            foreach(Student s in bcc)
            {
                Console.WriteLine("{0} : {1},{2}", s.name, s.chinese, s.math);
            }
        }
    }
}

結果:
Thomas : 100,100
Jonh : 70,50
Tom : 80,100

汽泡排序法(Bubble Sort)

底下的代碼, 為汽泡排序法, 其規則如下

1. 假設共有n個數(0~n-1)
2. 第 i 個數 (0~n-2)必需跟後面比(i+1~n-1), 如果前面的數比較大, 則對調

static void Main(string[] args)
{
	int n= 10;
	Random r = new Random();
	int[] d = new int[n];
	
	//產生10個亂數
	for (int i = 0; i < d.Length; i++)
	{
		d[i] = r.Next(1,100);
	}

	//列印未排序的陣列
	Console.WriteLine("排序前");
	foreach(int i in d)
	{
		Console.Write("{0} ", i);
	}
	Console.WriteLine();

	//排序
	for (int i = 0; i < d.Length - 1; i++)
	{
		for (int j = i + 1; j < d.Length; j++) { if (d[i] > d[j])
			{
				int temp = d[i];
				d[i] = d[j];
				d[j] = temp;
			}
		}
	}

	//列印已排序的陣列
	Console.WriteLine("排序後");
	foreach (int i in d)
	{
		Console.Write("{0} ", i);
	}
	Console.WriteLine();
}

結果
排序前
90 45 32 67 65 8 25 14 78 62
排序後
8 14 25 32 45 62 65 67 78 90

上述藍色的地方, 可以只使用一行代替
Array.Sort(d);

這是C#幫我們寫好的排序, 但上面的原理一定要搞懂, 因為那是資料結構必修且是最基本的演算法.

陣列Array