Biểu tượng chim cắt của Kestrel Exams KESTREL EXAMSLUYỆN TẬP ĐỂ ĐẠT
Bản dịch này do AI thực hiện và chưa được người bản ngữ kiểm duyệt. Nếu có khác biệt, bản tiếng Anh là bản chính. Mã nguồn được giữ nguyên bằng tiếng Anh. Ứng dụng luyện tập và tài liệu cho các kỳ thi chứng chỉ của Hoa Kỳ chỉ có bằng tiếng Anh. Read in English
JavaĐọc trong 19 phútMã đã được kiểm chứng

Mảng: tạo, truyền, và mảng dư chỗ

Mảng là một hàng các ô được đánh số, tất cả cùng chứa một kiểu. Bài hướng dẫn này nói về cách tạo mảng, đọc và duyệt qua nó, vì sao đưa mảng cho một phương thức thì phương thức đó có thể thay đổi nó, và mảng lớn hơn mức cần dùng kèm một số đếm riêng, là cách để thêm, tìm và xóa phần tử trong một cấu trúc không thể lớn lên. Mọi đoạn mã đều đã được biên dịch và chạy trên OpenJDK 21.

Luyện tập chủ đề này trong ứng dụng miễn phí →Tất cả bài hướng dẫn Java

Một danh sách chờ có các dòng đánh số#

Hãy hình dung tờ giấy kẹp trên bảng ở quầy đón khách của một quán ăn đông khách. Tờ giấy có sáu dòng in sẵn. Mỗi dòng chứa cùng một loại thứ, một nhóm khách đang chờ, và người đón khách có thể chỉ vào bất kỳ dòng nào bằng số của nó. Bạn không thể thêm dòng thứ bảy vào một tờ giấy đã in.

Mảng trong Java chính là tờ giấy đó. Mỗi dòng gọi là một phần tử, và số của nó là chỉ số. Cả bài hướng dẫn này xây dựng một chương trình nhỏ, Waitlist, cho quán ăn đó. Mỗi phần thêm một ý vào chương trình, và mỗi bước cho thấy đầu ra thật.

Kiểm tra bẫy: việc đếm bắt đầu từ đâu?

Mọi chỉ số đều bắt đầu từ 0. Một tờ giấy 6 dòng có các chỉ số từ 0 đến 5, nên dòng thứ sáu là chỉ số 5, không phải 6.

Khai báo, tạo và điền giá trị#

Bạn đã biết cách tạo một biến: kiểu, rồi tên, như int partySize;. Mảng dùng cùng hình thức đó với một thay đổi: dấu ngoặc vuông sau kiểu. int[] party; đọc là “party là một mảng các int”.

Tạo một mảng dùng được cần ba bước. Hãy học từng bước một trước; dạng ngắn gọn sẽ đến sau.

BướcMãTác dụng
1. Khai báoint[] party;tạo một biến có thể trỏ tới một mảng các int. Chưa có mảng nào tồn tại.
2. Tạoparty = new int[6];dành chỗ cho 6 int và cho biến trỏ tới đó. Số 6 là số lượng, không phải chỉ số cuối.
3. Khởi tạo giá trịparty[0] = 4;điền một giá trị vào một phần tử, dùng dấu ngoặc vuông và một chỉ số. Việc này gọi là khởi tạo giá trị cho nó.
Hãy thử trước

Trước khi chạy: một tờ giấy mới tinh chưa có tên nào trên đó. Bạn nghĩ Java đặt gì vào mỗi phần tử của new int[6]? Còn trong mỗi phần tử của new String[6]?

Xem đáp án

Số không trong mảng int, và null trong mảng String. Java không bao giờ để một phần tử có giá trị ngẫu nhiên; nó điền cho mỗi phần tử một giá trị mặc định. Hãy chạy chương trình dưới đây để kiểm tra.

Waitlist.java
import java.util.Arrays;

public class Waitlist {
    public static void main(String[] args) {
        int[] party;                  // declare: a variable for an array of ints
        party = new int[6];           // create: six lines, numbered 0 to 5
        String[] names = new String[6];
        System.out.println(Arrays.toString(party));
        System.out.println(Arrays.toString(names));

        party[0] = 4;                 // fill: line 0 gets a party of 4
        names[0] = "Ortiz";
        System.out.println(Arrays.toString(party));
        System.out.println(Arrays.toString(names));
    }
}
[0, 0, 0, 0, 0, 0]
[null, null, null, null, null, null]
[4, 0, 0, 0, 0, 0]
[Ortiz, null, null, null, null, null]

Số bắt đầu bằng 0 (hoặc 0.0), boolean bắt đầu bằng false, và bất cứ thứ gì là đối tượng, kể cả String, bắt đầu là null, nghĩa là “chưa trỏ tới gì”. Arrays.toString (từ java.util.Arrays) biến cả mảng thành một String nằm trong dấu ngoặc vuông, và println in String đó ra.

Bây giờ là các dạng ngắn gọn. Bước 1 và 2 vừa trong một dòng: int[] party = new int[6];. Và nếu bạn đã biết các giá trị, một danh sách khởi tạo làm cả ba bước cùng lúc và đếm số phần tử giúp bạn: int[] party = {4, 2, 5, 3};. Dạng ngoặc nhọn chỉ dùng được ở dòng khai báo biến. Ở bất kỳ chỗ nào khác, hãy viết party = new int[] {4, 2, 5, 3};.

length, và việc bước ra khỏi cuối mảng#

Mọi mảng đều biết kích thước của mình qua length. Nó là một trường, một giá trị lưu cùng với mảng, không phải phương thức, nên không có dấu ngoặc đơn: party.length. Chuỗi dùng phương thức s.length(), có dấu ngoặc đơn, và ArrayList dùng size(). Nhầm lẫn những cái này là một lỗi biên dịch kinh điển.

Giờ chương trình bắt đầu từ bốn nhóm khách đang chờ:

Waitlist.java
public class Waitlist {
    public static void main(String[] args) {
        int[] party = {4, 2, 5, 3};
        System.out.println(party.length);
        System.out.println(party[0]);
        System.out.println(party[party.length - 1]);
        System.out.println(party[4]);
    }
}
4
4
3
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
	at Waitlist.main(Waitlist.java:7)

Các chỉ số hợp lệ chạy từ 0 đến length - 1, nên nhóm cuối cùng là party[party.length - 1]. Yêu cầu chỉ số 4 trong một mảng có độ dài 4 vẫn biên dịch được, rồi dừng chương trình với ArrayIndexOutOfBoundsException. Hãy đọc thông báo: nó cho bạn cả hai con số, chỉ số bạn yêu cầu và độ dài bạn có.

Duyệt qua từng phần tử#

Người đón khách muốn hai con số: tổng cộng có bao nhiêu khách đang chờ, và quy mô trung bình của một nhóm.

Hãy thử trước

Các nhóm là 4, 2, 5 và 3. Hãy tự tính tổng và trung bình trước khi đọc mã.

Xem đáp án

Tổng là 14 và trung bình là 3,5. Hãy nhớ số 3,5 đó cho đầu ra tiếp theo.

Waitlist.java
public class Waitlist {
    public static void main(String[] args) {
        int[] party = {4, 2, 5, 3};

        int total = 0;                // the accumulator starts at 0
        for (int guests : party) {
            total += guests;          // and grows by one value per pass
        }
        System.out.println("Guests waiting: " + total);
        System.out.println("Average party: " + total / party.length);
    }
}
Guests waiting: 14
Average party: 3

Tổng đúng. Tổng chạy trong total được gọi là mẫu bộ cộng dồn (accumulator): bắt đầu một biến ở 0 trước vòng lặp, cộng một giá trị vào nó ở mỗi lượt, và đọc nó sau khi vòng lặp kết thúc.

Trung bình thì không đúng. 3 có hợp lý không? Bạn đã dự đoán 3,5. Đáp án phải nằm giữa nhóm nhỏ nhất (2) và nhóm lớn nhất (5), nên 3 là có thể. Chính vì vậy một đáp án sai như thế này lọt qua khi không ai dự đoán trước. Việc kiểm tra tương tự cũng quan trọng khi một công cụ hoặc AI đưa cho bạn câu trả lời: ước chừng trước xem nó nên là bao nhiêu, rồi so sánh.

Kiểm tra bẫy: chia số nguyên hay chia số thực?

Mỗi lần chia, hãy dừng lại và hỏi mỗi vế có kiểu gì. total là một int và party.length là một int, nên 14 / 4 là phép chia số nguyên và bỏ mất .5. Hãy biến một vế thành double trước bằng một phép ép kiểu, chuyển một giá trị sang kiểu khác: (double) total / party.length.

Với một thay đổi đó ở dòng cuối:

Guests waiting: 14
Average party: 3.5

Vòng lặp ở trên là vòng lặp for-each: for (int guests : party) đọc là “với mỗi int guests trong party”. Đó là cách ngắn gọn khi bạn chỉ cần từng giá trị. Khi bạn cần biết giá trị nằm ở đâu, hãy dùng vòng lặp for đếm. Nó có bốn phần: khởi tạo (int i = 1), điều kiện (i < party.length), cập nhật (i++) và thân bên trong dấu ngoặc nhọn.

Waitlist.java
public class Waitlist {
    public static void main(String[] args) {
        int[] party = {4, 2, 5, 3};

        int biggest = 0;              // index of the biggest party so far
        for (int i = 1; i < party.length; i++) {
            if (party[i] > party[biggest]) {
                biggest = i;
            }
        }
        System.out.println("Biggest: " + party[biggest] + " on line " + biggest);

        for (int guests : party) {
            guests = 0;               // changes the copy, not the array
        }
        System.out.println("Line 0 still holds " + party[0]);
    }
}
Biggest: 5 on line 2
Line 0 still holds 4

Phần tìm kiếm giả định dòng 0 là lớn nhất (biggest giữ một chỉ số) và để vòng lặp chứng minh điều ngược lại từ chỉ số 1. Nếu bắt đầu với giá trị lớn nhất bằng 0 thì sẽ cho đáp án sai khi mọi giá trị đều âm. Vòng lặp thứ hai cho thấy giới hạn của for-each: guests là bản sao của từng giá trị, nên đặt nó bằng 0 chỉ đổi bản sao và để nguyên mảng. Để thay đổi phần tử, hãy dùng vòng lặp đếm và viết party[i] = ....

Thu nhỏ về trường hợp nhỏ nhất. Để kiểm tra điều kiện vòng lặp, hãy thu nhỏ mảng đến khi bạn dò được trong đầu. Với một nhóm, {4}, vòng lặp for (int i = 0; i < party.length; i++) chạy với i = 0, rồi kiểm tra 1 < 1, là sai, nên nó chạy đúng một lần. Nếu viết với i <= party.length, nó sẽ chạy lần thứ hai với i = 1 và ném lỗi. Một phần tử là đủ nhỏ để chắc chắn.

Một quy ước đáng áp dụng: hãy viết i < party.length thay vì i <= party.length - 1. Cả hai đều đúng, nhưng cách đầu cho thấy trực tiếp số lượng và ít hơn một chỗ để sai. Nếu bạn thích cách thứ hai, đó không phải là lỗi.

Mảng được lưu dưới dạng tham chiếu#

Biến mảng không giữ các phần tử. Nó giữ một tham chiếu: một mũi tên trỏ tới nơi các phần tử nằm. Ở quán ăn, quầy đón khách và màn hình nhà bếp hiển thị cùng một danh sách. Đổi ở bên này thì bên kia thấy thay đổi, vì chỉ có một danh sách.

Waitlist.java
import java.util.Arrays;

public class Waitlist {
    public static void main(String[] args) {
        int[] party = {4, 2, 5, 3};
        int[] kitchenView = party;    // a second arrow to the same list
        kitchenView[1] = 3;           // the party on line 1 grew by one
        System.out.println(Arrays.toString(party));

        int[] snapshot = Arrays.copyOf(party, party.length);
        snapshot[0] = 9;
        System.out.println(Arrays.toString(party));
        System.out.println(Arrays.toString(snapshot));

        int[] same = {4, 3, 5, 3};
        System.out.println(party == same);
        System.out.println(Arrays.equals(party, same));

        System.out.println(party);
    }
}
[4, 3, 5, 3]
[4, 3, 5, 3]
[9, 3, 5, 3]
false
true
[I@659e0bfd

kitchenView = party sao chép mũi tên, không phải danh sách, nên đổi kitchenView[1] làm thay đổi điều party thấy. Arrays.copyOf tạo một danh sách thứ hai thật sự, nên đổi snapshot không ảnh hưởng đến party. Khi so sánh, == hỏi “cùng một danh sách không?” còn Arrays.equals hỏi “cùng giá trị theo cùng thứ tự không?”.

Dòng cuối được cho xem có chủ ý, vì bạn sẽ gặp nó. In chính biến mảng không in ra các giá trị. [I@659e0bfd là kiểu của mảng và một mã băm (hash code): [ nghĩa là “mảng”, I nghĩa là int, và phần sau @ là một số Java dùng để nhận diện đối tượng. Khi bạn chạy, nó sẽ khác. Thấy nó nghĩa là “bạn đã in tham chiếu”; hãy dùng Arrays.toString để xem nội dung.

Truyền một mảng cho phương thức, và trả về một mảng#

Java truyền mọi đối số dưới dạng bản sao giá trị của nó, gọi là truyền theo giá trị (pass-by-value). Với mảng, giá trị đó là mũi tên. Vì vậy một phương thức có thể thay đổi các phần tử của mảng của bên gọi, nhưng cho bản sao của mình trỏ sang một mảng mới thì không có tác dụng gì với bên gọi.

Hãy thử trước

Trong chương trình dưới đây, clearBoard đặt tham số của nó thành một mảng rỗng hoàn toàn mới. Sau lời gọi, waitlist của bên gọi có rỗng không?

Xem đáp án

Không. Phương thức chuyển bản sao mũi tên của nó sang một mảng mới. Mũi tên của bên gọi vẫn trỏ tới danh sách gốc, nên nó in lại [4, 2, 5, 4].

Waitlist.java
import java.util.Arrays;

public class Waitlist {
    public static void addGuests(int[] party, int line, int extra) {
        party[line] += extra;
    }

    public static void clearBoard(int[] party) {
        party = new int[6];
    }

    public static int[] bigParties(int[] party, int min) {
        int count = 0;
        for (int guests : party) {
            if (guests >= min) {
                count++;
            }
        }
        int[] result = new int[count];
        int next = 0;
        for (int guests : party) {
            if (guests >= min) {
                result[next] = guests;
                next++;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] party = {4, 2, 5, 3};
        addGuests(party, 3, 1);
        System.out.println(Arrays.toString(party));
        clearBoard(party);
        System.out.println(Arrays.toString(party));
        System.out.println(Arrays.toString(bigParties(party, 4)));
    }
}
[4, 2, 5, 4]
[4, 2, 5, 4]
[4, 5, 4]

addGuests đã thay đổi một phần tử, và thay đổi đó được giữ lại. clearBoard không thay đổi điều gì mà bên gọi thấy được. bigParties cho thấy cách trả về một mảng mới: dựng nó bên trong, rồi return nó. Kiểu trả về int[] cho biết phương thức trả về một mảng các int. Nó làm trong hai lượt duyệt, một lượt đếm xem kết quả phải lớn bao nhiêu và một lượt điền vào, vì kích thước mảng là cố định một khi đã tạo.

Hãy để ý rằng không có gì bên trong bigParties thực sự nói về khách quán ăn. Đưa cho nó số chỗ ngồi của một chiếc xe buýt, điểm số của một trò chơi hay số trang của một cuốn sách, nó vẫn trả về các giá trị bằng hoặc lớn hơn min. Một phương thức, viết một lần, dùng được cho mọi mảng của kiểu đó. Vì vậy, ngoài một ví dụ có chủ đề như thế này, tham số mảng thường được đặt tên chung như values hay nums; party ở đây chỉ để phục vụ câu chuyện.

Mảng bạn đã gõ từ chương trình đầu tiên#

Mọi chương trình bạn đã viết đều bắt đầu bằng public static void main(String[] args). Giờ bạn đọc được phần cuối: args là một mảng các String. Khi bạn chạy chương trình từ terminal, mọi từ bạn gõ sau tên lớp được đặt vào đó, mỗi từ một phần tử.

Waitlist.java
public class Waitlist {
    public static void main(String[] args) {
        System.out.println("Arguments: " + args.length);
        if (args.length > 0) {
            int first = Integer.parseInt(args[0]);
            System.out.println("First party: " + first + " guests");
            System.out.println("As text, doubled: " + args[0] + args[0]);
            System.out.println("As a number, doubled: " + (first + first));
        }
    }
}

Chạy với hai đối số, rồi không có đối số nào:

$ java Waitlist 4 2
Arguments: 2
First party: 4 guests
As text, doubled: 44
As a number, doubled: 8

$ java Waitlist
Arguments: 0

args[0] là String "4", không phải số 4, dù bạn gõ một chữ số. Đó là lý do “nhân đôi” nó như văn bản đã nối nó với chính nó và cho 44. Integer.parseInt biến văn bản thành một int. Khi không có đối số, args.length bằng 0, đó là lý do chương trình kiểm tra nó trước khi chạm vào args[0]. Nút Run của trình soạn thảo thường chạy main với một mảng rỗng, nên việc kiểm tra cũng quan trọng ở đó.

Mảng vừa đủ và mảng lớn hơn mức cần dùng#

Mảng không thể lớn lên, nên có hai cách dùng nó:

  • Mảng vừa đủ (perfect-size) có đúng số phần tử bằng số mục, nên length là số lượng mục. Nó phù hợp với dữ liệu mà bạn biết trước số lượng.
  • Mảng lớn hơn mức cần dùng (oversized) được tạo lớn hơn bạn cần, và một int riêng, thường gọi là size hoặc count, nhớ có bao nhiêu phần tử đang dùng. Nó phù hợp với các mục đến rồi đi.

Tờ giấy kẹp của quán ăn thuộc loại lớn hơn mức cần dùng: 6 dòng in sẵn, nhưng tại mỗi thời điểm chỉ một số dòng có chữ. Các nhóm đang dùng luôn được dồn ở phía trước, ở chỉ số từ 0 đến size - 1, và mọi thứ sau đó là chỗ trống dự phòng. Đây là mẫu mảng lớn hơn mức cần dùng kèm một số đếm, và quy tắc duy nhất của nó là: mọi vòng lặp dừng ở size, không phải ở length.

Thêm, tìm và xóa trong mảng lớn hơn mức cần dùng#

Đây là danh sách chờ dưới dạng danh sách tên, với ba thao tác được viết thành các phương thức dùng chung mảng và số đếm của nó. Hãy đọc chúng như một bộ.

Hãy thử trước

Danh sách có Ortiz, Lee, Patel và Nguyen. Lee đã được xếp chỗ ngồi, nên remove("Lee") chạy. Hãy viết ra danh sách và size mới trước khi nhìn đầu ra.

Xem đáp án

Ortiz, Patel, Nguyen, với size bằng 3. Patel và Nguyen mỗi người trượt lên một dòng để lấp khoảng trống.

Waitlist.java
public class Waitlist {
    static String[] names = new String[6];    // the clipboard: 6 lines
    static int size = 0;                      // how many lines are in use

    static boolean add(String name) {
        if (size == names.length) {
            return false;                     // clipboard full
        }
        names[size] = name;                   // first empty line
        size++;
        return true;
    }

    static int find(String name) {
        for (int i = 0; i < size; i++) {      // stop at size, not length
            if (names[i].equals(name)) {
                return i;
            }
        }
        return -1;                            // not on the list
    }

    static boolean remove(String name) {
        int at = find(name);
        if (at == -1) {
            return false;
        }
        for (int i = at; i < size - 1; i++) {
            names[i] = names[i + 1];          // slide each later name up
        }
        size--;
        return true;
    }

    static void show() {
        String line = "size " + size + ":";
        for (int i = 0; i < size; i++) {
            line += " " + names[i];
        }
        System.out.println(line);
    }

    public static void main(String[] args) {
        add("Ortiz");
        add("Lee");
        add("Patel");
        add("Nguyen");
        show();
        System.out.println("Lee is on line " + find("Lee"));
        System.out.println("Kim is on line " + find("Kim"));
        remove("Lee");
        show();
        add("Kim");
        add("Adams");
        add("Brooks");
        show();
        System.out.println("Room for Cho? " + add("Cho"));
    }
}
size 4: Ortiz Lee Patel Nguyen
Lee is on line 1
Kim is on line -1
size 3: Ortiz Patel Nguyen
size 6: Ortiz Patel Nguyen Kim Adams Brooks
Room for Cho? false
  • Thêm: đặt tên mới vào chỉ số size (dòng trống đầu tiên), rồi cộng 1 vào size. Hãy kiểm tra trước là còn dòng trống.
  • Tìm: đi qua các chỉ số từ 0 đến size - 1 và trả về chỉ số của kết quả khớp đầu tiên, hoặc -1 nếu không có. Đây là một tìm kiếm tuần tự (linear search). Các String được so sánh bằng equals, không phải ==.
  • Xóa: tìm tên, trượt mọi tên phía sau lên một dòng để lấp khoảng trống, rồi trừ 1 khỏi size. Bản sao cũ còn lại ở cuối giờ nằm trong vùng dự phòng, nên nó không còn được tính.
Kiểm tra bẫy: < size hay < size - 1?

Vòng lặp xóa dừng ở size - 1 vì nó đọc names[i + 1]. Hãy thu nhỏ để kiểm tra: với một tên trong danh sách và remove được gọi trên nó, at là 0 và điều kiện vòng lặp 0 < 0 là sai, nên nó chạy không lần nào và size thành 0. Nếu viết là i < size, lượt cuối sẽ đọc một dòng vượt quá các tên đang dùng, và trên một tờ giấy kẹp đã đầy thì đó là names[6], sẽ ném ArrayIndexOutOfBoundsException.

Nếu thứ tự không quan trọng, có một cách xóa nhanh hơn: sao chép tên cuối vào chỗ trống và trừ 1 khỏi size. Một lần di chuyển thay vì nhiều lần. Bài hướng dẫn về ArrayList cho thấy một lớp làm giúp bạn toàn bộ việc ghi sổ này.

Hãy tự gõ đoạn này

Đừng dán nó. Hãy thêm vào chương trình một phương thức insertAt(int index, String name) đặt một suất đặt chỗ đến muộn vào một dòng cho trước và dời mọi người bên dưới xuống một dòng. Tự gõ ra là cách để hướng của vòng lặp ghi nhớ được. Một dòng hợp lệ là từ 0 đến size; từ chối mọi giá trị khác. Hãy thử với Ortiz, Patel và Nguyen trong danh sách: chèn Kim vào dòng 0, rồi Lee vào dòng 2.

Xem đáp án

Hãy trượt từ phía sau, nếu không mỗi lần di chuyển sẽ ghi đè lên tên bạn cần ở bước kế tiếp:

static boolean insertAt(int index, String name) {
    if (size == names.length || index < 0 || index > size) {
        return false;
    }
    for (int i = size; i > index; i--) {
        names[i] = names[i - 1];          // move from the back first
    }
    names[index] = name;
    size++;
    return true;
}
size 4: Kim Ortiz Patel Nguyen
size 5: Kim Ortiz Lee Patel Nguyen

Điều mới trong bài hướng dẫn này#

  1. Kiểu dữ liệu int[]: kiểu bạn đã biết, cộng thêm dấu ngoặc vuông.
  2. new int[6] để dành chỗ cho 6 phần tử, tất cả được đặt về một giá trị mặc định.
  3. party[i] để đọc hoặc ghi một phần tử, với chỉ số từ 0 đến length - 1.
  4. length, một trường không có dấu ngoặc đơn, và các vòng lặp dùng nó: for-each cho giá trị, for đếm cho vị trí.
  5. Mảng là tham chiếu, nên sao chép hoặc truyền biến sẽ chia sẻ mảng; một phương thức cũng có thể dựng một mảng mới và return nó.
  6. Danh sách khởi tạo như {4, 2, 5, 3}, cùng Arrays.toString, Arrays.copyOf và Arrays.equals.
  7. String[] args là một mảng String bình thường.
  8. Mảng vừa đủ so với mảng lớn hơn mức cần dùng, và cách thêm, tìm, xóa trong mảng lớn hơn mức cần dùng.
Một câu để mang vào phòng thi

Mảng là một hàng cố định các phần tử được đánh số từ 0 đến length - 1, và biến giữ một mũi tên trỏ tới nó, không phải chính các phần tử. Sao chép hoặc truyền biến sẽ chia sẻ các phần tử; mảng lớn hơn mức cần dùng cần biến đếm size riêng, và mọi vòng lặp dừng ở đó.

Những chỗ dễ sai#

  • party.length() có dấu ngoặc đơn. Với mảng là length, một trường. Chuỗi dùng length().
  • Lặp với i <= party.length. Chỉ số hợp lệ cuối cùng là length - 1; cách này ném ArrayIndexOutOfBoundsException.
  • Chia hai int để lấy trung bình. 14 / 4 là 3. Hãy ép một vế sang double trước.
  • Nghĩ rằng int[] b = a; sao chép mảng. Nó sao chép tham chiếu. Hãy dùng Arrays.copyOf hoặc một vòng lặp.
  • So sánh mảng bằng == hoặc in chúng trực tiếp. Hãy dùng Arrays.equals và Arrays.toString.
  • Thay đổi phần tử qua biến for-each. Nó là một bản sao của giá trị. Hãy dùng vòng lặp đếm để thay đổi phần tử.
  • Lặp mảng lớn hơn mức cần dùng đến length. Hãy dừng ở size; phần còn lại là dự phòng, thường là null, và gọi equals trên null sẽ ném NullPointerException.
  • Quên size++ hoặc size--. Dữ liệu trông đúng còn số đếm thì sai, nên lần thêm hay vòng lặp kế tiếp sẽ hoạt động sai.
  • Dùng {4, 2, 5, 3} sau dòng khai báo. Hãy viết party = new int[] {4, 2, 5, 3}; thay vào đó.
  • Coi args[0] là một số. Nó là một String. Hãy chuyển nó bằng Integer.parseInt, và kiểm tra args.length trước.

Trong bài thi: nếu câu hỏi nói “viết một phương thức”, chỉ viết phương thức: phần khai báo, phần thân và return. Nếu nói “viết một chương trình”, hãy có đủ lớp và main. Đọc câu hỏi, đọc lại lần nữa, trả lời, rồi đọc thêm một lần để kiểm tra bạn đã làm đủ mọi phần.

Luyện tập#

Hãy trả lời từng câu trên giấy trước khi xem lời giải. Mọi đáp án có chạy mã đều đã được kiểm tra bằng cách biên dịch và chạy mã đó.

  1. Sau double[] p = new double[3]; và String[] s = new String[2];, mỗi mảng chứa gì?
  2. Hãy viết một phương thức countAbove(int[] nums, int limit) trả về số phần tử lớn hơn limit.
  3. Chương trình in ra gì?
    int[] x = {4, 5, 6};
    int[] y = x;
    y[2] = 0;
    x = new int[] {7, 8};
    System.out.println(Arrays.toString(x));
    System.out.println(Arrays.toString(y));
  4. Hãy viết một phương thức nhận một int[] và trả về một mảng mới với các phần tử theo thứ tự ngược, giữ nguyên mảng gốc.
  5. Một mảng lớn hơn mức cần dùng names có độ dài 10 và size là 4. Các chỉ số hợp lệ của những mục đang dùng là gì, và hai dòng nào thêm "Zoe"?
  6. Trong một mảng lớn hơn mức cần dùng chứa [A, B, C, D] với size bằng 4, hãy liệt kê các bước di chuyển mà phép xóa giữ thứ tự thực hiện để xóa B, và cho biết size mới.

Lời giải#

  1. p chứa [0.0, 0.0, 0.0] và s chứa [null, null]. new điền số bằng không, boolean bằng false, và các kiểu đối tượng bằng null.
  2. Vòng lặp for-each là đủ, vì chỉ cần các giá trị:
    public class QSum {
        public static int countAbove(int[] nums, int limit) {
            int count = 0;
            for (int n : nums) {
                if (n > limit) {
                    count++;
                }
            }
            return count;
        }
    
        public static void main(String[] args) {
            int[] temps = {71, 88, 93, 64, 90};
            System.out.println(countAbove(temps, 85));
        }
    }
    3
  3. y = x chia sẻ mảng đầu tiên, nên y[2] = 0 thay đổi nó. Sau đó x được cho trỏ tới một mảng mới, còn y vẫn trỏ tới mảng cũ:
    import java.util.Arrays;
    
    public class QTrace {
        public static void main(String[] args) {
            int[] x = {4, 5, 6};
            int[] y = x;
            y[2] = 0;
            x = new int[] {7, 8};
            System.out.println(Arrays.toString(x));
            System.out.println(Arrays.toString(y));
        }
    }
    [7, 8]
    [4, 5, 0]
  4. Tạo một mảng mới cùng độ dài và điền nó từ phía sau của mảng gốc:
    import java.util.Arrays;
    
    public class QReverse {
        public static int[] reversed(int[] a) {
            int[] r = new int[a.length];
            for (int i = 0; i < a.length; i++) {
                r[i] = a[a.length - 1 - i];
            }
            return r;
        }
    
        public static void main(String[] args) {
            int[] a = {1, 2, 3, 4};
            System.out.println(Arrays.toString(reversed(a)));
            System.out.println(Arrays.toString(a));
        }
    }
    [4, 3, 2, 1]
    [1, 2, 3, 4]
  5. Chỉ số từ 0 đến 3. Để thêm: names[size] = "Zoe"; rồi size++;, sau khi đã kiểm tra trước rằng size < names.length.
  6. B ở chỉ số 1. Trượt sang trái: chỉ số 1 nhận C, chỉ số 2 nhận D. Rồi size thành 3, nên các mục đang dùng là [A, C, D]. D cũ vẫn nằm ở chỉ số 3 giờ ở trong vùng dự phòng và bị bỏ qua.

Danh sách kiểm tra trước khi thi#

Đây là các mục trong danh sách chủ đề Bài thi 2 của môn học mà bài hướng dẫn này đề cập. Chỉ đánh dấu mỗi mục khi bạn làm được mà không cần nhìn.

  • ☐  Tôi có thể khai báo một mảng, tạo chỗ chứa cho nó bằng new, và khởi tạo giá trị, kể cả bằng danh sách khởi tạo.
  • ☐  Tôi có thể truyền một mảng cho phương thức và trả về một mảng từ phương thức, và dự đoán điều bên gọi thấy.
  • ☐  Tôi có thể giải thích mảng vừa đủ và mảng lớn hơn mức cần dùng, và vì sao mảng được lưu dưới dạng tham chiếu.
  • ☐  Tôi có thể duyệt qua mọi phần tử bằng vòng lặp đếm và vòng lặp for-each.
  • ☐  Tôi có thể tìm một phần tử, xóa một phần tử và thêm một phần tử trong mảng lớn hơn mức cần dùng.

Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí

40 câu luyện tập về khai báo, truyền và mảng lớn hơn mức cần dùng, với mọi đáp án mã đều được kiểm tra bằng cách biên dịch và chạy. Miễn phí, dùng ngoại tuyến, không cần tài khoản.

Luyện tập mảng →

Câu hỏi thường gặp#

Làm thế nào để khai báo và tạo một mảng trong Java?

Khai báo biến với dấu ngoặc vuông sau kiểu, chẳng hạn int[] scores;. Tạo chỗ chứa bằng new và một kích thước, chẳng hạn scores = new int[5];. Hoặc làm cả hai và điền giá trị cùng lúc bằng một danh sách khởi tạo: int[] scores = {90, 85, 77};.

Giá trị mặc định trong một mảng Java mới tạo là gì?

Các phần tử số bắt đầu bằng 0 (hoặc 0.0), phần tử boolean bằng false, phần tử char bằng ký tự null, và phần tử của bất kỳ kiểu đối tượng nào, kể cả String, bằng null.

Với mảng là length hay length()?

length, không có dấu ngoặc đơn. Nó là một trường của mọi mảng. Chuỗi dùng phương thức length() có dấu ngoặc đơn, còn ArrayList dùng size().

Điều gì gây ra ArrayIndexOutOfBoundsException?

Dùng một chỉ số nhỏ hơn 0 hoặc bằng hay lớn hơn độ dài của mảng. Các chỉ số hợp lệ chạy từ 0 đến length - 1. Nguyên nhân thường gặp là điều kiện vòng lặp viết là i <= array.length thay vì i < array.length.

Tại sao thay đổi một mảng bên trong phương thức lại làm nó thay đổi đối với bên gọi?

Vì biến mảng giữ một tham chiếu đến mảng. Phương thức nhận một bản sao của tham chiếu đó, cùng trỏ tới một mảng, nên các thay đổi ở phần tử đều được bên gọi thấy. Tuy nhiên, cho tham số trỏ sang một mảng hoàn toàn mới thì không ảnh hưởng đến biến của bên gọi.

Mảng lớn hơn mức cần dùng (oversized array) là gì?

Là mảng được tạo lớn hơn số phần tử đang lưu, đi kèm một biến int riêng đếm số phần tử đang dùng. Các phần tử được giữ ở chỉ số từ 0 đến size - 1, nên có thể thêm và xóa phần tử mà không cần tạo mảng mới, cho đến khi mảng đầy.

Đề xuất chỉnh sửa

Có chỗ nào chưa rõ? Có chủ đề nào bạn muốn chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có bài hướng dẫn mới: một số bài ở đây ra đời vì có người hỏi.