Mảng trong C#: khai báo, Length, Sort, mảng 2 chiều, jagged

Mảng (array) chứa một số lượng cố định các phần tử cùng kiểu, nằm liền nhau trong bộ nhớ. Bạn chọn độ dài khi tạo mảng, đọc và ghi phần tử theo chỉ số bắt đầu từ 0, và độ dài đó không bao giờ thay đổi sau khi tạo.

Khai báo và khởi tạo mảng

Kiểu của một mảng là kiểu phần tử theo sau bởi []. Có nhiều cách để tạo mảng:

using System;

class Program
{
    static void Main()
    {
        int[] scores = new int[4];                     // 4 elements, all 0
        string[] names = { "Ana", "Ben", "Chloe" };     // initializer
        double[] prices = new double[] { 2.5, 9.99 };   // explicit form
        var days = new[] { "Mon", "Tue", "Wed" };       // type inferred: string[]

        scores[0] = 90;
        scores[3] = 72;

        Console.WriteLine(string.Join(", ", scores));
        Console.WriteLine(names[1]);
        Console.WriteLine(prices.Length + " prices, " + days.Length + " days");
    }
}

Đầu ra:

90, 0, 0, 72
Ben
2 prices, 3 days

new int[4] gán cho mọi phần tử giá trị mặc định của kiểu: 0 với số, false với bool, null với chuỗi và các kiểu tham chiếu khác. Cách viết ngắn { "Ana", "Ben" } chỉ dùng được khi khai báo; khi gán cho một biến đã có, bạn cần viết names = new[] { "Dev", "Eli" };.

Length, chỉ số và phần tử cuối

Chỉ số chạy từ 0 đến Length - 1. Length là một thuộc tính nên không có cặp ngoặc tròn (khác với phương thức Count() của LINQ).

using System;

class Program
{
    static void Main()
    {
        int[] temps = { 18, 21, 25, 19, 16 };

        Console.WriteLine("Count: " + temps.Length);
        Console.WriteLine("First: " + temps[0]);
        Console.WriteLine("Last: " + temps[temps.Length - 1]);

        try
        {
            Console.WriteLine(temps[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

Đầu ra:

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

Đọc hoặc ghi ra ngoài phạm vi sẽ ném ra IndexOutOfRangeException lúc chạy; trình biên dịch không bắt được lỗi này. Nguyên nhân thường gặp là điều kiện vòng lặp viết thành i <= arr.Length thay vì i < arr.Length.

Từ C# 8 trở đi có thêm cú pháp chỉ số tính từ cuối và range, ngắn gọn hơn khi lấy phần tử cuối hay cắt một đoạn mảng:

int last = temps[^1];        // 16
int[] middle = temps[1..4];  // { 21, 25, 19 }, a new array

Duyệt mảng bằng vòng lặp

Vòng lặp for cho bạn chỉ số; foreach cho bạn từng phần tử và rõ ràng hơn khi bạn chỉ cần đọc.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 4.50m, 12.00m, 3.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = Math.Round(prices[i] * 1.10m, 2); // raise every price by 10%
        }

        decimal total = 0;
        foreach (decimal p in prices)
        {
            total += p;
        }

        Console.WriteLine(string.Join(" | ", prices));
        Console.WriteLine("Total: " + total);
    }
}

Đầu ra:

4.95 | 13.20 | 3.58
Total: 21.73

Biến của foreach là chỉ đọc: viết p = 0; trong vòng lặp sẽ gây lỗi biên dịch. Muốn thay đổi phần tử, hãy duyệt bằng chỉ số.

Sắp xếp, đảo ngược và tìm kiếm

Lớp static Array chứa các phương thức hỗ trợ. Array.Sort sắp xếp tại chỗ và không trả về gì, nên thứ tự ban đầu sẽ mất.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79 };

        Array.Sort(scores);
        Console.WriteLine("Ascending:  " + string.Join(", ", scores));

        Array.Reverse(scores);
        Console.WriteLine("Descending: " + string.Join(", ", scores));

        Console.WriteLine("Index of 60: " + Array.IndexOf(scores, 60));
        Console.WriteLine("Index of 99: " + Array.IndexOf(scores, 99));
        Console.WriteLine("Any above 90: " + Array.Exists(scores, s => s > 90));
        Console.WriteLine("First below 75: " + Array.Find(scores, s => s < 75));

        string[] names = { "chloe", "Ana", "ben" };
        Array.Sort(names, StringComparer.OrdinalIgnoreCase);
        Console.WriteLine(string.Join(", ", names));

        string[] fruits = { "kiwi", "banana", "fig" };
        Array.Sort(fruits, (a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", fruits));
    }
}

Đầu ra:

Ascending:  60, 72, 79, 88, 95
Descending: 95, 88, 79, 72, 60
Index of 60: 4
Index of 99: -1
Any above 90: True
First below 75: 72
Ana, ben, chloe
fig, kiwi, banana

Array.IndexOf trả về -1 khi không tìm thấy giá trị. Array.Find trả về giá trị mặc định của kiểu (ở đây là 0) khi không có phần tử nào khớp, điều này gây mơ hồ với số; hãy dùng Array.FindIndex khi chuyện đó quan trọng. Sắp xếp giảm dần chỉ với một lệnh gọi là Array.Sort(scores, (a, b) => b.CompareTo(a)).

Nếu cần kết quả đã sắp xếp mà không đụng đến mảng gốc, LINQ trả về một mảng mới: var sorted = scores.OrderBy(s => s).ToArray();. Xem thêm LINQ.

Thay đổi kích thước: mảng không thể dài thêm

Độ dài là cố định. Array.Resize tạo một mảng mới với kích thước bạn yêu cầu, sao chép các phần tử, rồi cập nhật biến mà bạn truyền vào bằng ref.

using System;

class Program
{
    static void Main()
    {
        string[] queue = { "Ana", "Ben" };
        string[] before = queue;

        Array.Resize(ref queue, 4);
        queue[2] = "Chloe";

        Console.WriteLine(queue.Length);
        Console.WriteLine(before.Length);             // the old array is unchanged
        Console.WriteLine(queue[3] == null);          // new slots get the default
        Console.WriteLine(ReferenceEquals(before, queue));
    }
}

Đầu ra:

4
2
True
False

Mỗi lần resize đều sao chép toàn bộ phần tử. Tăng kích thước mảng từng phần tử một trong vòng lặp rất chậm, và đó chính là việc List<T> làm giúp bạn hiệu quả hơn, bằng cách nhân đôi mảng bên trong của nó.

Mảng là kiểu tham chiếu: sao chép

Gán một mảng cho biến khác chỉ sao chép tham chiếu, không sao chép phần tử. Khi đó cả hai tên đều trỏ đến cùng một mảng.

using System;

class Program
{
    static void Main()
    {
        int[] original = { 1, 2, 3 };

        int[] alias = original;
        alias[0] = 100;
        Console.WriteLine(original[0]); // 100: same array

        int[] copy = (int[])original.Clone();
        copy[1] = 200;
        Console.WriteLine(original[1]); // 2: independent array

        int[] target = new int[5];
        Array.Copy(original, 0, target, 1, 3); // source, start, dest, start, count
        Console.WriteLine(string.Join(", ", target));
    }
}

Đầu ra:

100
2
0, 100, 2, 3, 0

Điều tương tự xảy ra khi bạn truyền mảng vào một phương thức: phương thức đó có thể thay đổi phần tử của bên gọi. Clone, Array.Copy, CopyTo và ToArray() của LINQ đều tạo bản sao nông (shallow copy). Với mảng chứa đối tượng, mảng mới giữ tham chiếu đến chính các đối tượng cũ, nên thay đổi copy[0].Name vẫn làm thay đổi thứ mà original[0] nhìn thấy.

So sánh mảng bằng == là so sánh tham chiếu. Để so sánh nội dung, hãy dùng a.SequenceEqual(b) từ System.Linq.

Mảng 2 chiều (đa chiều)

Một lưới hình chữ nhật được khai báo bằng dấu phẩy bên trong cặp ngoặc vuông. Truy cập phần tử bằng [row, col].

using System;

class Program
{
    static void Main()
    {
        int[,] seats = new int[2, 3]; // 2 rows, 3 columns
        seats[0, 1] = 1;
        seats[1, 2] = 1;

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

        Console.WriteLine("Rows: " + grid.GetLength(0));
        Console.WriteLine("Cols: " + grid.GetLength(1));
        Console.WriteLine("Length: " + grid.Length + ", Rank: " + grid.Rank);

        for (int r = 0; r < seats.GetLength(0); r++)
        {
            for (int c = 0; c < seats.GetLength(1); c++)
            {
                Console.Write(seats[r, c] == 1 ? "X " : ". ");
            }
            Console.WriteLine();
        }
    }
}

Đầu ra:

Rows: 2
Cols: 3
Length: 6, Rank: 2
. X . 
. . X 

Length của mảng 2 chiều là tổng số phần tử (6 với lưới 2 nhân 3), vì vậy các vòng lặp lồng nhau dùng GetLength(0) và GetLength(1). Rank là số chiều. Mảng 3 chiều cũng làm tương tự: new int[4, 4, 4] và cube[x, y, z]. Vòng lặp foreach trên mảng 2 chiều duyệt qua mọi phần tử theo từng hàng.

Jagged array (mảng của các mảng)

Jagged array int[][] là mảng mà mỗi phần tử lại là một mảng, và mỗi mảng con có thể có độ dài riêng. Nó phù hợp với dữ liệu kiểu "đơn hàng của từng khách hàng", nơi các hàng có kích thước khác nhau.

using System;

class Program
{
    static void Main()
    {
        int[][] orders = new int[3][]; // 3 rows, none created yet
        orders[0] = new[] { 20, 35 };
        orders[1] = new[] { 12 };
        orders[2] = new[] { 8, 15, 40, 22 };

        for (int i = 0; i < orders.Length; i++)
        {
            Console.WriteLine("Customer " + i + ": " + orders[i].Length
                + " orders, " + string.Join(", ", orders[i]));
        }

        int[][] empty = new int[2][];
        Console.WriteLine(empty[0] == null);
    }
}

Đầu ra:

Customer 0: 2 orders, 20, 35
Customer 1: 1 orders, 12
Customer 2: 4 orders, 8, 15, 40, 22
True

new int[3][] chỉ tạo mảng bên ngoài; mỗi hàng ban đầu là null, và truy cập orders[0][0] trước khi gán hàng sẽ ném ra NullReferenceException. Cú pháp new int[3][4] không được phép; bạn phải tự tạo từng hàng.

Dùng [,] cho một lưới thực sự (bàn cờ, ma trận, điểm ảnh) và [][] khi các hàng có độ dài khác nhau hoặc bạn muốn hoán đổi cả hàng.

Mảng và List

Chuyển đổi qua lại chỉ cần một lệnh gọi: new List<int>(arr) hoặc arr.ToList(), và list.ToArray(). List<T> là phiên bản có thể mở rộng.

Lỗi thường gặp

• Viết i <= arr.Length trong vòng lặp. Chỉ số hợp lệ cuối cùng là Length - 1; code này sẽ ném ra IndexOutOfRangeException.
• In trực tiếp mảng. Console.WriteLine(arr) in ra System.Int32[]; hãy dùng string.Join.
• Nghĩ rằng Array.Sort trả về mảng đã sắp xếp. Nó trả về void và sắp xếp tại chỗ.
• Sao chép bằng =. Cách này chỉ sao chép tham chiếu; hãy dùng Clone() hoặc ToArray().
• Dùng các hàng của jagged array trước khi tạo. Mỗi hàng của new T[n][] là null cho đến khi được gán.
• Dùng Length để lấy số hàng của mảng 2 chiều. Thuộc tính này đếm mọi phần tử; hãy dùng GetLength(0).