1.Arrays.fill()

Khi làm việc với mảng, các lập trình viên Java thường cần điền vào mảng với cùng một giá trị. Tất nhiên, bạn có thể viết một vòng lặp và chỉ cần gán một số giá trị cho từng ô của mảng trong vòng lặp:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

Hoặc bạn có thể chỉ cần gọi Arrays.fill()phương thức, phương thức này thực hiện chính xác điều tương tự: nó lấp đầy mảng đã truyền với giá trị đã truyền. Đây là giao diện của nó:

Arrays.fill(name, value)

Và mã trong ví dụ trên có thể được làm cho gọn và rõ ràng hơn một chút:

int[] x = new int[100];
Arrays.fill(x, 999);

Bạn cũng có thể sử dụng Arrays.fill()phương thức để điền không phải toàn bộ mảng mà là một phần của mảng với một số giá trị:

Arrays.fill(name, first, last, value)

Trong đó first và last là chỉ số của ô đầu tiên và ô cuối cùng được điền.

Theo truyền thống lâu đời của Java, hãy nhớ rằng phần tử cuối cùng không được bao gồm trong phạm vi.

Ví dụ:

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

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

Chúng tôi đang điền vào các ô x[3], x[4], x[5]và x[6]với giá trị 999. Các ô của một mảng được đánh số bắt đầu từ số không!

Biến strchứa giá trị:
"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

Phương Arrays.fill()thức chỉ hoạt động với mảng một chiều. Nếu bạn chuyển một mảng hai chiều cho phương thức, nó sẽ được coi là một chiều, với tất cả các hệ quả tiếp theo.

2.Arrays.copyOf()

Như bạn đã biết, bạn không thể thay đổi kích thước một mảng sau khi nó đã được tạo.

Nhưng nếu bạn thực sự muốn thì sao?

Java webinar

Chà, nếu bạn thực sự muốn, thì bạn có thể!

  • Tạo một mảng mới có độ dài mong muốn
  • Sao chép tất cả các phần tử từ mảng đầu tiên vào nó.

Nhân tiện, đây chính xác là những gì Arrays.copyOf()phương pháp làm. Đây là những gì gọi nó trông giống như:

Type[] name2 = Arrays.copyOf(name, length);

Phương thức này không thay đổi mảng hiện có mà thay vào đó, tạo một mảng mới và sao chép các phần tử của mảng cũ vào đó.

Nếu các phần tử không vừa (độ dài nhỏ hơn độ dài của mảng hiện có ), thì các giá trị bổ sung sẽ bị bỏ qua.

Nếu độ dài của mảng mới lớn hơn độ dài của mảng cũ, thì các ô được lấp đầy bằng số không.

Ví dụ:

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

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Biến str2chứa giá trị:
"[1, 2, 3, 4, 5]"

Biến str3chứa giá trị:
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

Và nếu bạn muốn lấy một mảng có độ dài 5 từ một mảng có độ dài 10, nhưng bạn cần nó chứa 5 phần tử cuối cùng thay vì 5 phần tử đầu tiên thì sao?

Trong trường hợp này, một phương thức khác của Arrayslớp sẽ có ích — phương thức Arrays.copyOfRange(). Đây là những gì nó trông giống như khi chúng ta gọi nó:

Type[] name2 = Arrays.copyOfRange(name, first, last);

Phương thức này cũng tạo một mảng mới, nhưng lấp đầy nó bằng các phần tử từ một vị trí tùy ý trong mảng ban đầu. Trong đó đầu tiên và cuối cùng là các chỉ số của phần tử đầu tiên và cuối cùng sẽ được đưa vào mảng mới.

Theo truyền thống lâu đời của Java, hãy nhớ rằng phần tử cuối cùng không được bao gồm trong phạm vi.

Ví dụ:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Biến str2chứa giá trị:
"[16, 17, 18, 19, 20]"

Biến str3chứa giá trị:
"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

À, món ngon nhất: phân loại . Mảng được sắp xếp khá thường xuyên trong lập trình. Ba hành động phổ biến nhất khi làm việc với mảng là:

  • Sắp xếp một mảng
  • Tìm phần tử tối thiểu (hoặc tối đa) của một mảng
  • Xác định chỉ số của phần tử trong mảng (tìm phần tử trong mảng)

Đây chính xác là lý do tại sao những người tạo ra Java đã đưa sort()phương thức này vào Arrayslớp. Đây là những gì gọi nó trông giống như:

Arrays.sort(name);

Phương thức này sắp xếp mảng đã truyền theo thứ tự tăng dần.

Ví dụ:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);

String str = Arrays.toString(x);


Biến strchứa giá trị:
"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Tuyệt vời, phải không? Bạn đã gọi một phương thức và bây giờ bạn có một mảng được sắp xếp. Xinh đẹp.

Nhân tiện, bạn có thể sử dụng phương pháp này để sắp xếp không chỉ toàn bộ mảng mà chỉ một phần của mảng đó. Đây là những gì gọi nó trông giống như:

Arrays.sort(name, first, last);

Trong đó đầu tiên và cuối cùng là các chỉ số của ô đầu tiên và ô cuối cùng mà sắp xếp sẽ chạm vào.

Theo truyền thống lâu đời của Java, hãy nhớ rằng phần tử cuối cùng không được bao gồm trong phạm vi.

Ví dụ:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

Biến strchứa giá trị:
"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

Để sắp xếp mảng, Java sử dụng thuật toán sắp xếp nhanh nhất — QuickSort . Độ phức tạp tính toán của nó phụ thuộc vào kích thước của mảng và được tính bằng công thức N log(N).

Việc sắp xếp một mảng gồm 1000 phần tử sẽ bao gồm khoảng 3000 phép so sánh các phần tử của mảng. Việc sắp xếp một mảng gồm một triệu phần tử sẽ bao gồm khoảng 6 triệu phép so sánh.

5.Arrays.binarySearch()

Chà, và phương thức cuối cùng thú vị nhất của lớp Arrayslà có thể tìm kiếm một giá trị đã cho trong một mảng. Đây không phải là tìm kiếm thông thường — đó là tìm kiếm nhị phân được yêu thích . Nó hiểu rõ điều này:

  • Đầu tiên, mảng được sắp xếp.
  • Sau đó, phần tử ở giữa của mảng được so sánh với phần tử mà chúng ta đang tìm kiếm.
  • Nếu phần tử lớn hơn phần tử ở giữa, thì việc tìm kiếm tiếp tục ở nửa bên phải của mảng.
  • Nếu phần tử chúng ta đang tìm kiếm nhỏ hơn phần tử ở giữa, thì quá trình tìm kiếm sẽ tiếp tục ở nửa bên trái của mảng.

Vì mảng đã được sắp xếp nên có thể loại bỏ một nửa mảng trong một lần so sánh. Sau đó, trong bước tiếp theo, chúng tôi tung ra một nửa khác, v.v.

Cách tiếp cận này làm cho tìm kiếm nhị phân rất nhanh. Trong một mảng có một triệu phần tử (!), nó có thể tìm thấy chỉ mục của phần tử mong muốn chỉ trong 20 phép so sánh. Thiếu sót của phương pháp này là mảng phải được sắp xếp trước và việc sắp xếp cũng mất thời gian.

Đây là những gì gọi nó trông giống như:

int index = Arrays.binarySearch(name, value);

Đâu namelà tên của mảng, phải được truyền vào đã được sắp xếp (ví dụ: sử dụng phương Arrays.sort()thức). Và valuelà phần tử chúng tôi đang tìm kiếm trong mảng. Kết quả trả về của phương thức là chỉ số của phần tử mảng mong muốn .

Ví dụ:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);
 xlà:
{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

4
1(chỉ số 0và 2cũng được chấp nhận)
8
-7

Nếu mảng chứa nhiều phiên bản của phần tử đang được tìm kiếm, thì thuật toán sẽ chỉ trả về chỉ mục của một trong số chúng (chẳng hạn, không có gì đảm bảo rằng nó sẽ là phần tử đầu tiên hoặc ngược lại - phần tử cuối cùng trong số này các phần tử trùng lặp)."

Nếu phần tử không được tìm thấy trong mảng, thì chỉ số sẽ âm.

6. Liên kết đến tài liệu Oracle trên Arrayslớp

Nếu bạn cực kỳ quan tâm, bạn có thể đọc mọi thứ về Arrayslớp và tất cả các phương thức của nó trong tài liệu chính thức a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">trên trang web của Oracle.

Ví dụ, bạn có thể đọc về phương pháp Arrays.mismatch()và Arrays.compare(). Có thể bạn sẽ thấy chúng hữu ích bằng cách nào đó.

Và đừng nhầm lẫn bởi số lượng phương pháp. Mỗi phương pháp có 5-10 biến thể, chỉ khác nhau về loại tham số của chúng.