# Array
在 C# 中，陣列（Array）是一種用來儲存固定大小的同類型元素的資料結構。陣列讓你能夠以索引的方式來存取這些元素。以下是一些關於 C# 陣列的簡單介紹：

1. 陣列的宣告和初始化
宣告陣列
你可以先宣告一個陣列，並指定它的類型和大小，但不立即初始化它的內容。例如：

    int[] numbers; // 宣告一個整數型別的陣列

初始化陣列
你可以在宣告時直接初始化陣列，並指定它的元素：

    int[] numbers = new int[5]; // 宣告一個包含 5 個整數的陣列，所有元素初始為 0

使用初始值設定陣列
你也可以在宣告時就給陣列賦初值：

    int[] numbers = { 1, 2, 3, 4, 5 }; // 宣告並初始化一個包含 5 個整數的陣列

2. 存取和修改陣列元素
每個陣列元素都可以通過索引來存取，索引從 0 開始。例如：

    int[] numbers = { 1, 2, 3, 4, 5 };
    int firstNumber = numbers[0]; // 取得陣列中的第一個元素，結果是 1
    numbers[1] = 10; // 將陣列中的第二個元素設為 10

3. 陣列的基本操作
遍歷陣列
你可以使用 for 或 foreach 迴圈來遍歷陣列中的所有元素：

    int[] numbers = { 1, 2, 3, 4, 5 };

    // 使用 for 迴圈
    for (int i = 0; i < numbers.Length; i++)
    {
        Console.WriteLine(numbers[i]);
    }

    // 使用 foreach 迴圈
    foreach (int number in numbers)
    {
        Console.WriteLine(number);
    }

取得陣列長度
你可以使用 Length 屬性來獲取陣列的長度（即元素的個數）：

    int[] numbers = { 1, 2, 3, 4, 5 };
    int length = numbers.Length; // length 的值是 5

4. 多維陣列
C# 支援多維陣列，例如二維陣列（矩陣）：

    int[,] matrix = new int[3, 3]; // 宣告一個 3x3 的二維陣列

    // 初始化二維陣列
    matrix[0, 0] = 1;
    matrix[0, 1] = 2;
    matrix[0, 2] = 3;
    matrix[1, 0] = 4;
    matrix[1, 1] = 5;
    matrix[1, 2] = 6;
    matrix[2, 0] = 7;
    matrix[2, 1] = 8;
    matrix[2, 2] = 9;

5. 陣列的其他特性
陣列是固定大小的：一旦你創建了陣列，它的大小就不能再更改。如果需要可變大小的容器，可以使用 List<T> 類型。
陣列的索引是從 0 開始的：陣列的第一個元素索引是 0，第二個元素索引是 1，以此類推。

---

### ArraySort()
Array.Sort() 是 C# 中用來對陣列進行排序的方法。它會根據陣列元素的自然順序（對於數字是從小到大，對於字串是字母順序）來對陣列進行排序。這是一個非常實用的方法，尤其是在需要處理排序的數據時。

using System;

class Program
{
    static void Main()
    {
        // 宣告並初始化整數陣列
        int[] numbers = { 5, 2, 8, 1, 3 };

        // 輸出排序前的陣列
        Console.WriteLine("排序前:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine();

        // 使用 Array.Sort() 方法對陣列進行排序
        Array.Sort(numbers);

        // 輸出排序後的陣列
        Console.WriteLine("排序後:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
    }
}

Output:
        排序前:
        5 2 8 1 3 
        排序後:
        1 2 3 5 8 

---

### Array.Reverse()
Array.Reverse() 是 C# 中用來將陣列元素順序反轉的方法。它會將陣列中元素的順序反向排列，從而使原本的第一個元素變成最後一個，第二個變成倒數第二個，以此類推。

using System;

class Program
{
    static void Main()
    {
        // 宣告並初始化整數陣列
        int[] numbers = { 1, 2, 3, 4, 5 };

        // 輸出反轉前的陣列
        Console.WriteLine("反轉前:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine();

        // 使用 Array.Reverse() 方法對陣列進行反轉
        Array.Reverse(numbers);

        // 輸出反轉後的陣列
        Console.WriteLine("反轉後:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
    }
}
Output:
        反轉前:
        1 2 3 4 5 
        反轉後:
        5 4 3 2 1 

若只想要部分反轉?

int[] numbers = { 1, 2, 3, 4, 5 };
Array.Reverse(numbers, 1, 3); // 反轉從索引 1 開始的 3 個元素
這會將 numbers 陣列中的第二到第四個元素反轉，結果為 { 1, 4, 3, 2, 5 }。

### Array.Clear()
Array.Clear() 是 C# 中用來清除陣列中指定範圍的元素的方法。它會將指定範圍的所有元素設置為該陣列元素類型的預設值。例如，對於數字類型（如 int），預設值是 0；對於字串類型，預設值是 null。

public static void Clear(Array array, int index, int length)

* array: 需要進行清除的陣列。
* index: 從哪個索引位置開始清除。
* length: 要清除的元素數量。

假設你有一個整數陣列，並且你想要將其中的一部分元素清除（即設置為 0）：

using System;

class Program
{
    static void Main()
    {
        // 宣告並初始化整數陣列
        int[] numbers = { 1, 2, 3, 4, 5 };

        // 輸出清除前的陣列
        Console.WriteLine("清除前:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine();

        // 使用 Array.Clear() 方法清除陣列中的一部分元素
        // 這裡我們從索引 1 開始，清除 3 個元素
        Array.Clear(numbers, 1, 3);

        // 輸出清除後的陣列
        Console.WriteLine("清除後:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
    }
}

Output:
        清除前:
        1 2 3 4 5 
        清除後:
        1 0 0 0 5 

對於其他類型的預設值：
* bool，預設值是 false。
* string，預設值是 null。
* 對於參考型別（例如對象），預設值也是 null。

### Array.IndexOf()
Array.IndexOf() 是 C# 中一個用於查找數組中特定元素位置的方法。它返回該元素在數組中的索引位置，如果找不到該元素則返回 -1。這個方法是靜態方法，屬於 System.Array 類，並且可以用於任何類型的數組。

基本概念
* 定義：Array.IndexOf() 方法在數組中搜索指定的元素，並返回該元素第一次出現的索引。
* 用途：這個方法用於查找數組中某個元素的位置，適用於處理需要快速定位元素的情況，如搜索和數據匹配等。

using System;

class Program
{
    static void Main(string[] args)
    {
        // 定義一個整數數組，包含一些預設的數字
        int[] numbers = new int[]
        {
            90, 199, 22, 50, 30
        };

        // 提示用戶輸入要搜尋的數字
        Console.WriteLine("請輸入你要搜尋的數字:");

        // 從用戶的輸入讀取一個數字，並將其轉換為整數
        int search = Convert.ToInt32(Console.ReadLine());

        // 使用 Array.IndexOf() 方法查找數組中的數字
        // 這裡我們指定從索引 1 開始，在索引範圍 1-2 中查找
        // 也就是說，它只會在 { 199, 22 } 這兩個數字中查找
        int position = Array.IndexOf(numbers, search, 1, 2);

        // 檢查找到的索引值是否大於 -1，表示數字是否存在於指定範圍內
        if (position > -1)
        {
            // 如果找到了數字，顯示數字和其在數組中的位置
            // position + 1 是因為索引從 0 開始，但我們想顯示從 1 開始的位置信息
            Console.WriteLine($"Number {search} has been found at position {position + 1}");
        }
        else
        {
            // 如果找不到數字，告訴用戶數字不在範圍內
            Console.WriteLine($"Number {search} has not been found");
        }
    }
}

假設數組為 { 90, 199, 22, 50, 30 }：

用戶輸入 199，則輸出：Number 199 has been found at position 2。
用戶輸入 22，則輸出：Number 22 has been found at position 3。
用戶輸入 50，則輸出：Number 50 has not been found（因為查找範圍是索引 1 到 2）。
用戶輸入 90，則輸出：Number 90 has not been found（因為查找範圍是索引 1 到 2）。

### Array.Copy()
Array.Copy()是 C# 中用來複製一個陣列的內容到另一個陣列中的方法。這個方法可以用來複製整個陣列或部分陣列，並且可以指定從源陣列和目標陣列的哪個索引位置開始複製。
Array.Copy() 方法有多個重載，最常見的重載形式如下：

public static void Copy(Array sourceArray, Array destinationArray, int length);
public static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);

* sourceArray: 要複製數據的源數組。
* destinationArray: 要將數據複製到的目標數組。
* length: 要複製的元素數量。
* sourceIndex (可選): 開始複製的源數組的索引位置。
* destinationIndex (可選): 開始將元素複製到目標數組的索引位置。

using System;

class Program
{
    static void Main()
    {
        // 定義源數組
        int[] sourceArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        
        // 定義目標數組，大小為 10
        int[] destinationArray = new int[10];
        
        // 將 sourceArray 的第 3 到第 7 個元素（4, 5, 6, 7, 8）複製到 destinationArray 的索引 5 開始的位置
        Array.Copy(sourceArray, 3, destinationArray, 5, 5);

        // 打印目標數組
        Console.WriteLine("Destination Array:");
        foreach (int item in destinationArray)
        {
            Console.Write(item + " "); // Output: 0 0 0 0 0 4 5 6 7 8
        }
    }
}

在這個例子中：

1. 源數組 (sourceArray): 這是一個包含 10 個整數的數組 { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }。
2. 目標數組 (destinationArray): 初始化為 10 個元素的空數組，所有值默認為 0。
3. Copy(): sourceArray, 3: 從 source array 的 index 3 開始，對應 4。
destinationArray, 5: 複製到目標 array 的 index 5 開始的位置。
5: 要複製的元素數量是 5，即複製 4, 5, 6, 7, 8。
4. 結果: 目標數組 destinationArray 的前五個元素保持為默認值 0，而從 index 5 開始，填補了來自 sourceArray 的 4, 5, 6, 7, 8。