Mảng (Array) trong Java là một cấu trúc dữ liệu dùng để lưu trữ một nhóm các phần tử có cùng kiểu dữ liệu. Về bản chất, mảng chiếm một vùng bộ nhớ liên tục và được quản lý thông qua một danh tính duy nhất. Khi khai báo, hệ thống sẽ phân bổ khối nhớ cố định, nên kích thước không thể thay đổi sau khi khởi tạo.

Để làm việc hiệu quả với mảng, cần nắm rõ bốn thuộc tính cốt lõi:

• Tên mảng: Identifier dùng để tham chiếu đến toàn bộ cấu trúc trong code.
• Kiểu dữ liệu: Loại giá trị mà các phần tử trong mảng phải tuân thủ (primitive hoặc reference).
• Chiều: Số lượng chỉ số (index) cần thiết để định vị một phần tử cụ thể.
• Kích thước: Tổng số phần tử tối đa mà mảng có thể chứa.

Mảng Một Chiều (1D Array)

Quá trình xây dựng mảng một chiều bao gồm hai bước: khai báo tham chiếu và cấp phát bộ nhớ thông qua toán tử new. Cú pháp tiêu chuẩn:

kiểuDữLieu[] tenMang = new kiểuDữLieu[soLuongPhanTu];

Sau khi khởi tạo, việc truy cập phần tử được thực hiện qua chỉ số bắt đầu từ 0. Thuộc tính length là một trường public final, tự động trả về kích thước thực tế của mảng.

Khởi tạo tĩnh và động

Khởi tạo tĩnh: Gán giá trị ngay tại thời điểm khai báo, JVM tự động suy ra kích thước.

Khởi tạo động: Cấp phát vùng nhớ trước với kích thước xác định, sau đó gán giá trị từng phần tử hoặc thông qua vòng lặp.

Dưới đây là ví dụ minh họa cách tạo mảng, gán giá trị và tính tổng các phần tử:

package com.example.arraybasics;

public class ArrayCalculator {
    public static void main(String[] args) {
        int[] dataSet = new int[10];
        
        for (int idx = 0; idx < dataSet.length; idx++) {
            dataSet[idx] = idx + 1;
        }
        
        int total = 0;
        for (int value : dataSet) {
            total += value;
        }
        
        System.out.println("Tổng các phần tử: " + total);
    }
}

Quản lý bộ nhớ và Xử lý ngoại lệ

Java thực hiện kiểm tra biên tự động cho mảng. Việc truy cập ngoài khoảng [0, length - 1] sẽ kích hoạt ArrayIndexOutOfBoundsException. Đây là lỗi thời gian chạy (runtime error) thường gặp, do đó cần luôn xác nhận giới hạn mảng trước khi thao tác, đặc biệt khi dùng biến làm chỉ số.

Thao tác nâng cao trên mảng một chiều

Các phép toán như duyệt mảng, tìm giá trị lớn nhất, hay đảo ngược thứ tự phần tử đều có thể triển khai bằng cấu trúc lặp. Khi đảo ngược mảng, phương pháp sử dụng hai chỉ số tiến lại gần nhau sẽ tiết kiệm bộ nhớ đệm và tránh tạo mảng trung gian không cần thiết:

package com.example.arraybasics;

public class ArrayOperations {
    public static void main(String[] args) {
        int[] values = {4, 7, 2, 9, 5};
        
        // In mảng ra console
        printSequence(values);
        
        // Tính tổng
        int sum = 0;
        for (int num : values) sum += num;
        System.out.println("Tổng: " + sum);
        
        // Tìm giá trị lớn nhất
        int maxVal = values[0];
        for (int i = 1; i < values.length; i++) {
            if (values[i] > maxVal) {
                maxVal = values[i];
            }
        }
        System.out.println("Giá trị lớn nhất: " + maxVal);
        
        // Đảo ngược mảng
        int[] inverted = invertSequence(values);
        System.out.print("Mảng sau khi đảo ngược: ");
        printSequence(inverted);
    }

    public static int[] invertSequence(int[] source) {
        int[] result = new int[source.length];
        for (int i = 0, j = source.length - 1; i < source.length; i++, j--) {
            result[j] = source[i];
        }
        return result;
    }

    private static void printSequence(int[] arr) {
        for (int item : arr) {
            System.out.print(item + " ");
        }
        System.out.println();
    }
}

Mảng Hai Chiều (2D Array)

Mảng hai chiều thực chất là một mảng các mảng một chiều. Cách khai báo và khởi tạo linh hoạt hơn, cho phép mỗi hàng có số lượng cột khác nhau (còn gọi là jagged array). Cú pháp cấp phát:

kiểuDữLieu[][] tenMang2D = new kiểuDữLieu[sốHàng][sốCột];

Khởi tạo tĩnh thường dùng khi đã biết trước toàn bộ giá trị:

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

Để duyệt qua toàn bộ phần tử trong mảng hai chiều, cần sử dụng vòng lặp lồng nhau. Vòng ngoài xác định hàng, vòng trong xác định cột dựa trên độ dài của từng hàng cụ thể:

package com.example.arraybasics;

public class MatrixTraversal {
    public static void main(String[] args) {
        int[][] matrix = {
            {10, 20, 30},
            {40, 50},
            {60, 70, 80, 90}
        };

        for (int rowIdx = 0; rowIdx < matrix.length; rowIdx++) {
            System.out.print("Dòng " + rowIdx + ": ");
            for (int colIdx = 0; colIdx < matrix[rowIdx].length; colIdx++) {
                System.out.print(matrix[rowIdx][colIdx] + " ");
            }
            System.out.println();
        }
    }
}

Khi tham chiếu đến phần tử cụ thể, cú pháp luôn tuân theo thứ tự tênMảng[chỉSốHàng][chỉSốCột]. Cơ chế này mở rộng tương tự cho mảng ba chiều hoặc cao hơn, nhưng trong thực tế phát triển ứng dụng, mảng hai chiều và danh sách đối tượng (List) thường được ưu tiên hơn do tính linh hoạt và dễ quản lý bộ nhớ.