Mảng (Array), cách sử dụng mảng trong java

5560

MẢNG TRONG JAVA

  • Thông thường, mảng (array) là một tập hợp các phần tử có cùng kiểu được lưu trữ gần nhau trong bộ nhớ.
  • Mảng trong java là một đối tượng chứa các phần tử có kiểu dữ liệu giống nhau. Mảng là một cấu trúc dữ liệu nơi lưu trữ các phần tử giống nhau. Với mảng trong java chúng ta chỉ có thể lưu trữ một tập các phần tử có số lượng phần tử cố định.
  • Mảng trong java lưu các phần tử theo chỉ số, chỉ số của phần tử đầu tiên là 0.

KIỂU CỦA MẢNG TRONG JAVA

Có hai kiểu mảng trong java: Mảng 1 chiều và mảng 2 chiều.

KHỞI TẠO MẢNG

Để khai báo một mảng, khai báo loại biến với dấu ngoặc vuông []:

dataType[] arr;
dataType []arr; 
dataType arr[];

Ví dụ chúng ta đã khai báo một biến chứa một chuỗi các chuỗi.

Để chèn giá trị vào nó, chúng ta có thể sử dụng một mảng bằng chữ – đặt các giá trị trong danh sách được phân tách bằng dấu phẩy, bên trong dấu ngoặc nhọn:

String[] cars = { "Honda", "BMW", "Ford", "Mazda" };

Để tạo một mảng các số nguyên, bạn có thể viết:

int[] myNum = { 10, 20, 30, 40 };

TRUY CẬP PHẦN TỬ CỦA MẢNG

Bạn truy cập một phần tử mảng bằng cách sử dụng số chỉ mục (index).

Ví dụ:

package vn.edu.thaynhuom.array;
 
public class TruyCapArray1 {
    public static void main(String[] args) {
        String[] cars = { "Honda", "BMW", "Ford", "Mazda" };
        System.out.println(cars[0]);
    }
}

Kết quả:

Honda

THAY ĐỔI PHẦN TỬ CỦA MẢNG

Để thay đổi giá trị của một phần tử cụ thể, hãy sử dụng số chỉ mục:

Ví dụ:

package vn.edu.thaynhuom.array;
 
public class TruyCapArray2 {
    public static void main(String[] args) {
        String[] cars = { "Honda", "BMW", "Ford", "Mazda" };
        // thay đổi phần tử đầu tiên của mảng cars
        cars[0] = "Morning";
        // hiển thị phần tử đầu tiên của mảng cars
        System.out.println("Phần tử đầu tiên: " + cars[0]);
    }
}

Kết quả:

Phần tử đầu tiên: Morning

ĐỘ DÀI CỦA MẢNG

Để biết có bao nhiêu phần tử một mảng, sử dụng thuộc tính length :

Ví dụ:

package vn.edu.thaynhuom.array;
 
public class DodaiArray1 {
    public static void main(String[] args) {
        String[] cars = { "Honda", "BMW", "Ford", "Mazda" };
        System.out.println("Độ dài của mảng cars là: " + cars.length);
    }
}

Kết quả:

4

DUYỆT MẢNG

Có 2 các để duyệt các phần tử của mảng:

  • Sử dụng vòng lặp for
  • Sử dụng foreach
Sử dụng vòng lặp for

Bạn có thể lặp qua các phần tử mảng bằng vòng lặp for và sử dụng thuộc tính length để chỉ định số lần vòng lặp sẽ chạy. Ví dụ:

package vn.edu.thaynhuom.array;
 
public class DuyetArray1 {
    public static void main(String[] args) {
        String[] cars = { "Honda", "BMW", "Ford", "Mazda" };
        for (int i = 0; i < cars.length; i++) {
            System.out.println(cars[i]);
        }
    }
}

Kết quả:

Honda
BMW
Ford
Mazda
Sử dụng foreach
package vn.edu.thaynhuom.array;
 
public class DuyetArray2 {
    public static void main(String[] args) {
        String[] cars = { "Honda", "BMW", "Ford", "Mazda" };
        for (String car : cars) {
            System.out.println(car);
        }
    }
}

Kết quả:

Honda
BMW
Ford
Mazda
So sánh for với foreach

Nếu bạn so sánh vòng lặp for và vòng lặp foreach, bạn sẽ thấy rằng phương thức foreach dễ viết hơn, nó không yêu cầu bộ đếm (sử dụng thuộc tính length) và nó dễ đọc hơn.

SẮP XẾP MẢNG

Có nhiều phương thức mảng có sẵn, ví dụ Sort(), sắp xếp một mảng theo thứ tự bảng chữ cái hoặc theo thứ tự tăng dần, ví dụ:

package vn.edu.thaynhuom.array;
 
import java.util.Arrays;
 
public class DuyetArray2 {
    public static void main(String[] args) {
        String[] cars = { "Honda", "BMW", "Ford", "Mazda" };
        // sap xep mangr cars theo thu tu tang dan
        Arrays.sort(cars);
        System.out.println("Mảng cars sau khi được sắp xếp:");
        for (String car : cars) {
            System.out.println(car);
        }
    }
}

Kết quả:

Mảng cars sau khi được sắp xếp:
BMW
Ford
Honda
Mazda

MỘT SỐ CÁCH KHỞI TẠO MẢNG KHÁC

Trong Java, có nhiều cách khác nhau để tạo một mảng:

// tạo một mảng có độ dài 4, thêm các phần tử sau tạo
String[] cars1 = new String[4];
 
// tạo một mảng không cần chỉ định số phần tử cụ thể
String[] cars2 = new String[] { "Honda", "BMW", "Ford", "Mazda" };
 
// tạo một mảng không cần chỉ định số phần tử cụ thể
// và không cần dùng từ khóa new
String[] cars3 = { "Honda", "BMW", "Ford", "Mazda" };

Bạn có thể chọn bất kỳ cách khởi tạo nào. Trong hướng dẫn của chúng tôi, chúng tôi sẽ thường sử dụng tùy chọn cuối cùng, vì nó nhanh hơn và dễ đọc hơn.

Một trường hợp khác, nếu bạn khai báo một mảng và khởi tạo nó sau, bạn phải sử dụng từ khóa new:

// khai báo một mảng
String[] cars;
 
// thêm giá trị, sử dụng từ khóa new
cars = new String[] { "Honda", "BMW", "Ford" };
 
// nếu không dùng new sẽ bị lỗi
cars = {"Honda","BMW","Ford"};

TRUYỀN MẢNG VÀO PHƯƠNG THỨC

Chúng ta có thể truyền mảng vào phương thức, điều này giúp tái sử dụng code logic để xử lý mảng bất kỳ. Ví dụ:

public class TestArray2 {
    static void min(int arr[]) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++)
            if (min > arr[i]) {
                min = arr[i];
            }
        System.out.println(min);
    }
 
    public static void main(String args[]) {
        int a[] = { 33, 3, 4, 5 };
        min(a);// truyền mảng tới phương thức
    }
}

Kết quả:

3

SAO CHÉP MỘT MẢNG

Sao chép thông qua toán tử gán

Chỉ đơn giản là dùng phép gán thông thường cho 2 mảng. Ví dụ minh hoạ:

class CopyArray {
    public static void main(String[] args) {
       
        int [] numbers = {1, 2, 3, 4, 5, 6};
        int [] positiveNumbers = numbers;    // copying arrays

        for (int number: positiveNumbers) {
           System.out.print(number + ", ");
        }
    }
}

Kết quả:

1, 2, 3, 4, 5, 6

Việc sử dụng cách này để sao chép mảng có vẻ rất tối ưu thế nhưng nó lại có một vấn đề.

Nếu bạn thay đổi các phần tử của một mảng trong ví dụ trên, các phần tử tương ứng của mảng kia cũng bị thay đổi.

class AssignmentOperator {
   public static void main(String[] args) {
      
      int [] numbers = {1, 2, 3, 4, 5, 6};
      int [] positiveNumbers = numbers;    // copying arrays
      
      numbers[0] = -1;

      for (int number: positiveNumbers) {
         System.out.print(number + ", ");
      }
  }
}

Kết quả:

-1, 2, 3, 4, 5, 6

Khi phần tử đầu tiên của mảng numbers được thay đổi thành -1, phần tử đầu tiên của mảng positiveNumbers cũng trở thành -1. Đó là bởi vì cả hai mảng đề cập đến cùng một đối tượng mảng.

Sử dụng cấu trúc vòng lặp

Ví dụ minh hoạ:

import java.util.Arrays;

class ArraysCopy {
   public static void main(String[] args) {
      
      int [] source = {1, 2, 3, 4, 5, 6};
      int [] destination = new int[6];

      for (int i = 0; i < source.length; ++i) {
         destination[i] = source[i];
      }
      
      // converting array to string
      System.out.println(Arrays.toString(destination));
  }
}

Kết quả:

[1, 2, 3, 4, 5, 6]

Ở đây, vòng lặp for được sử dụng để lặp qua từng phần tử của mảng source. Trong mỗi lần lặp, phần tử tương ứng của mảng source được sao chép vào mảng destination.

Các mảng source và destination không có chung reference (cách sao chép này gọi là deep copy). Có nghĩa là, nếu các phần tử của một mảng (source hoặc destination) bị thay đổi, các phần tử tương ứng của mảng kia vẫn không thay đổi.

Hàm toString () được sử dụng để chuyển đổi mảng thành chuỗi (chỉ nhằm mục đích output).

Có một cách tốt hơn (so với việc sử dụng vòng lặp) để sao chép các mảng trong Java, cách đó chính là sử dụng hàm arraycopy() và hàm copyOfRange().

Sử dụng hàm arraycopy()

Lớp System chứa hàm arraycopy(), hàm này cho phép ta sao chép dữ liệu từ mảng này sang mảng khác.

Hàm arraycopy() vừa hiệu quả lại vừa linh hoạt. Bởi vì hàm này cho phép ta sao chép một phần xác định của mảng nguồn sang mảng đích.

public static void arraycopy(Object src, int srcPos,
                      Object dest, int destPos, int length)

Trong đó:

  • src là mảng bạn muốn sao chép.
  • srcPos là vị trí bắt đầu (chỉ số) trong mảng src.
  • dest là mảng đích: các phần tử của mảng src sẽ được sao chép vào mảng này.
  • destPos là vị trí bắt đầu (chỉ số) trong  mảng dest.
  • length là số phần tử cần sao chép.

Lưu ý, giá trị khởi tạo mặc định của các phần tử trong môt mảng kiểu int là 0.

import java.util.Arrays;

class ArraysCopy {
   public static void main(String[] args) {
      int[] n1 = {2, 3, 12, 4, 12, -2};
      
      int[] n3 = new int[5];

      // Creating n2 array of having length of n1 array
      int[] n2 = new int[n1.length];
      
      // copying entire n1 array to n2
      System.arraycopy(n1, 0, n2, 0, n1.length);
      System.out.println("n2 = " + Arrays.toString(n2));  
      
      // copying elements from index 2 on n1 array
      // copying element to index 1 of n3 array
      // 2 elements will be copied
      System.arraycopy(n1, 2, n3, 1, 2);
      System.out.println("n3 = " + Arrays.toString(n3));  
  }
}

Kết quả:

n2 = [2, 3, 12, 4, 12, -2]
n3 = [0, 12, 4, 0, 0]
Sử dụng hàm CopyOfRange()

Ngoài ra, để sao chép mảng, bạn có thể sử dụng hàm copyOfRange() được xác định trong class java.util.Arrays. Bạn không cần tạo mảng đích trước khi gọi hàm. Truy cập trang này để tìm hiểu thêm về hàm copyOfRange ().

// To use toString() and copyOfRange() method
import java.util.Arrays;

class ArraysCopy {
   public static void main(String[] args) {
      
      int[] source = {2, 3, 12, 4, 12, -2};
      
      // copying entire source array to destination
      int[] destination1 = Arrays.copyOfRange(source, 0, source.length);      
      System.out.println("destination1 = " + Arrays.toString(destination1)); 
      
      // copying from index 2 to 5 (5 is not included) 
      int[] destination2 = Arrays.copyOfRange(source, 2, 5); 
      System.out.println("destination2 = " + Arrays.toString(destination2));   
  }
}

Kết quả:

destination1 = [2, 3, 12, 4, 12, -2]
destination2 = [12, 4, 12]
Sao chép mảng 2d

Ví dụ minh hoạ:

import java.util.Arrays;

class ArraysCopy {
public static void main(String[] args) {
      
      int[][] source = {
            {1, 2, 3, 4}, 
            {5, 6},
            {0, 2, 42, -4, 5}
            };

      int[][] destination = new int[source.length][];

      for (int i = 0; i < destination.length; ++i) {

         // allocating space for each row of destination array
         destination[i] = new int[source[i].length];

         for (int j = 0; j < destination[i].length; ++j) {
            destination[i][j] = source[i][j];
         }
      }
     
      // displaying destination array
      System.out.println(Arrays.deepToString(destination));  
      
  }
}

Kết quả:

[[1, 2, 3, 4], [5, 6], [0, 2, 42, -4, 5]]

Bạn có thể thấy, ở đây, ta đã sử dụng hàm Arrays’ deepToString(). Hàm deepToString() biểu diễn mảng đa chiều môt cách tối ưu hơn, cụ thể trong ví dụ này là mảng 2 chiều. Tìm hiểu thêm về hàm deepToString ().

Bạn có thể thay thế vòng lặp bên trong của phần code trên bằng hàm System.arraycopy() hoặc hàm Arrays.copyOf() mảng trong trường hợp đối với mảng một chiều.

Cách sử dụng hàm arraycopy() để làm bài trên:

import java.util.Arrays;

class AssignmentOperator {
public static void main(String[] args) {
      
      int[][] source = {
            {1, 2, 3, 4}, 
            {5, 6},
            {0, 2, 42, -4, 5}
            };

      int[][] destination = new int[source.length][];

      for (int i = 0; i < source.length; ++i) {

         // allocating space for each row of destination array
         destination[i] = new int[source[i].length];
         System.arraycopy(source[i], 0, destination[i], 0, destination[i].length);
      }
     
      // displaying destination array
      System.out.println(Arrays.deepToString(destination));      
  }
}

MẢNG 2 CHIỀU & ĐA CHIỀU

Trong TH này, dữ liệu được lưu trữ theo hàng và cột theo chỉ mục (hay còn gọi là dạng ma trận).

Mảng hai chiều và đa chiều trong Java:

Trong TH này, dữ liệu được lưu trữ theo hàng và cột theo chỉ mục (hay còn gọi là dạng ma trận).

Khai báo mảng đa chiều:

dataType[][] arr;
dataType [][]arr;
dataType arr[][];
dataType []arr[];

Ví dụ về khởi tạo và gán giá trị cho mảng đa chiều trong java.

int[][] arr=new int[3][3]; // 3 hàng 3 cột
arr[0][0]=1;  
arr[0][1]=2;  
arr[0][2]=3;  
arr[1][0]=4;  
arr[1][1]=5;  
arr[1][2]=6;  
arr[2][0]=7;  
arr[2][1]=8;  
arr[2][2]=9;

Ví dụ khai báo và khởi tạo mảng đa chiều trong java.

public class TestArray3 {
    public static void main(String args[]) {
 
        // khai báo và khởi tạo mảng 2 chiều
        int arr[][] = { { 1, 2, 3 }, { 2, 4, 5 }, { 4, 4, 5 } };
 
        // in mảng 2 chiều r màn hình
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
 
    }
}

Kết quả:

1 2 3 
2 4 5 
4 4 5

Ví dụ cộng 2 ma trận (mảng đa chiều) trong Java:

package vn.edu.thaynhuom.array;
 
public class CongMaTran {
    public static void main(String[] args) {
        // tao hai ma tran
        int a[][] = { { 1, 3, 4 }, { 3, 4, 5 } };
        int b[][] = { { 1, 3, 4 }, { 3, 4, 5 } };
 
        // tao ma tran khac de luu giu ket qua phep cong hai ma tran
        int c[][] = new int[2][3];
 
        // cong va in tong hai ma tran
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                c[i][j] = a[i][j] + b[i][j];
                System.out.print(c[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Kết quả:

2 6 8 
6 8 10

LỢI ÍCH & HẠN CHẾ CỦA MẢNG

Lợi thế
  • Tối ưu code: Mảng giúp lấy hoặc sắp xếp dữ liệu dễ dàng.
  • Truy cập ngẫu nhiên: Chúng ta có thể lấy dữ liệu được lưu trữ ở bất kỳ vị trí nào thông qua chỉ số.
Hạn chế
  • Giới hạn kích thước: Chúng ta phải khởi tạo kích thước của mảng trong java trước khi sử dụng. Không thể thay đổi được kích thước của nó lúc runtime. Collection framework được sử dụng trong java để giải quyết vấn đề này.

GIỚI THIỆU LỚP ARRAY

Lớp java.util.Arrays chứa nhiều phương thức static đa dạng để xếp thứ tự và tìm kiếm các mảng, so sánh các mảng và điền các phần tử vào mảng.

STTPhương thức và Miêu tả
1public static int binarySearch(Object[] a, Object key)Tìm kiếm mảng của Object (byte, int, double, …) đã cho với giá trị đã xác định bởi sử dụng thuật toán tìm kiếm nhị phân. Mảng này phải được xếp thứ tự trước khi gọi phương thức này. Nó trả về chỉ mục của từ khóa tìm kiếm, nếu nó nằm trong danh sách, nếu không thì, bằng (-(điểm chèn + 1)).
2public static boolean equals(long[] a, long[] a2)Trả về true nếu hai mảng long đã cho là cân bằng nhau. Hai mảng này được cho là cân bằng nếu cả hai mảng chứa cùng số lượng phần tử, và tất cả các cặp phần tử tương ứng của hai mảng là cân bằng. Phương thức tương tự có thể được sử dụng bởi tất cả kiểu dữ liệu gốc khác (byte, short, int, …).
3public static void fill(int[] a, int val)Gán giá trị int đã cho tới mỗi phần tử của mảng int đã cho. Phương thức tương tự có thể được sử dụng bởi tất cả kiểu dữ liệu gốc khác (byte, short, int, …).
4public static void sort(Object[] a)Xếp thứ tự mảng các đối tượng đã cho theo thứ tự tăng dần, theo thứ tự tự nhiên của các phần tử. Phương thức tương tự có thể được sử dụng bởi tất cả kiểu dữ liệu gốc khác (byte, short, int, …).

VIDEO THỰC HÀNH VỀ MẢNG

Add xin cảm ơn, chúc thành công!

BÌNH LUẬN

Vui lòng nhập bình luận của bạn
Vui lòng nhập tên của bạn ở đây