Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Java CoreJunior26 phút đọc

Java cơ bản: vòng lặp, hàm, call stack và pass-by-value

Ôn 13 thẻ
Trong bài này

Cụm bài Java cơ bản: 1. JVM và JDK · 2. Hello World và ba loại lỗi · 3. Biến và kiểu dữ liệu · 4. Toán tử và rẽ nhánh · 5. Vòng lặp và hàm · 6. Mảng và chuỗi · 7. Console và file text · 8. Byte stream và serialization

Bài này giải quyết hai việc mọi chương trình đều gặp: làm một việc nhiều lần (vòng lặp) và chia code thành việc nhỏ dùng lại được (hàm). Đọc xong, bạn giải thích được call stack, phạm vi biến và vì sao Java luôn truyền tham trị, ba câu hay bị hỏi khi phỏng vấn. Nên đọc trước toán tử và rẽ nhánh; bài tiếp theo là mảng và chuỗi, và đây là nền cho cấu trúc dữ liệu và thuật toán.

1. Vòng lặp

Ý chính: khi vài câu lệnh cần chạy lặp lại, bọc chúng trong vòng lặp thay vì copy-paste. Mọi vòng lặp cần một điều kiện dừng và một lệnh làm điều kiện đó thay đổi, để chắc chắn sẽ kết thúc.

Cách viết một vòng lặp bất kỳ: (1) xác định các lệnh cần lặp, (2) bọc chúng trong vòng lặp, (3) viết điều kiện dừng và lệnh cập nhật biến điều khiển.

while và do-while

// while: kiểm tra điều kiện TRƯỚC, có thể không chạy lần nào
int countdown = 3;
while (countdown > 0) {
    System.out.println(countdown);
    countdown--;              // quên dòng này là lặp vô hạn
}

// do-while: chạy TRƯỚC rồi mới kiểm tra, luôn chạy ít nhất một lần
Scanner in = new Scanner(System.in);
int choice;
do {
    System.out.print("Chọn 1-3: ");
    choice = in.nextInt();
} while (choice < 1 || choice > 3);
  • do-while hợp với kiểu “hỏi người dùng cho tới khi nhập hợp lệ”.
  • Bug vòng lặp thường nằm ở hai chỗ: điều kiện sai (dùng <= thay vì <, gây off-by-one, tức lệch một đơn vị) hoặc thân vòng lặp không làm điều kiện thay đổi (lặp vô hạn).
  • Thân vòng lặp được phép rỗng, ví dụ while (!ready()) ;. Nhưng kiểu chờ bận này (busy-waiting, CPU quay liên tục chỉ để hỏi “xong chưa”) ngốn CPU.

for và for-each

for (int i = 0; i < 5; i++) {          // khởi tạo; điều kiện; cập nhật
    System.out.print(i + " ");
}

int[] prices = {120, 80, 45};
for (int price : prices) {             // for-each: không có chỉ số, không gán lại được phần tử
    System.out.print(price + " ");
}

Vòng lặp lồng nhau

for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.printf("%d×%d=%-3d", j, i, i * j);
    }
    System.out.println();
}

Lệnh in bên trong chạy 1 + 2 + … + 9 = 45 lần, tức n(n+1)/2. Đếm số phép tính như vậy là cách ước lượng độ phức tạp: hai vòng lồng nhau thường là O(n²), và với n = 10⁵ là 10¹⁰ phép tính, không chạy kịp.

Lời khuyên của khoá: đừng lồng quá 3 tầng; vượt mức đó thì tách hàm hoặc đổi thuật toán (dùng HashMap, sắp xếp…). Bản tam giác ở trên là một biến thể; bảng cửu chương đầy đủ dạng lưới 9×9 nằm ở bài tập 3.

break, continue và nhãn

for (int n : numbers) {
    if (n < 0) continue;     // bỏ qua phần còn lại của lượt này
    if (n == 0) break;       // thoát hẳn khỏi vòng lặp
    process(n);
}

outer:
for (int[] row : grid) {
    for (int cell : row) {
        if (cell == target) break outer;   // thoát luôn cả vòng ngoài
    }
}

break thoát vòng gần nhất; break outer thoát vòng có nhãn (label, tên đặt trước vòng lặp) outer. continue chỉ bỏ phần còn lại của lượt hiện tại.

Hai ví dụ kinh điển trong giáo trình: đoán output trước khi chạy
int sum = 0, number = 0;
while (number < 20) {
    number++;
    sum += number;
    if (sum >= 100) break;     // dừng khi tổng chạm 100
}
// number = 14, sum = 105 (1 + 2 + … + 13 = 91 < 100, cộng thêm 14 thì vượt)

sum = 0; number = 0;
while (number < 20) {
    number++;
    if (number == 10 || number == 11) continue;
    sum += number;
}
// sum = 189: tổng 1..20 là 210, trừ đi 10 và 11

Ở ví dụ thứ hai, number++ nằm trước continue nên vòng while không bị kẹt. Đặt nó ở cuối thân vòng lặp là gặp ngay cái bẫy dưới đây.

2. Hàm (method)

Ý chính: gom một đoạn code làm một việc thành một hàm để dùng lại, dễ đọc và dễ test. Trong Java, mọi “function” đều là method vì phải nằm trong class.

//  modifier  kiểu trả về  tên        tham số
    static    double       bmi(double weightKg, double heightM) {
        return weightKg / (heightM * heightM);
    }

static void printReceipt(String customer) {   // void: không trả về gì
    if (customer == null) return;             // return; kết thúc hàm void sớm
    System.out.println("Khách: " + customer);
}

Method static gọi qua tên class; method thường gọi qua một object (xem bài OOP). Signature gồm tên và danh sách kiểu tham số. Kiểu trả về không thuộc signature, nên không thể overload hai hàm chỉ khác nhau ở kiểu trả về.

Các bộ phận của một method, với thuật ngữ tiếng Anh hay gặp:

public static int max(int num1, int num2) {   // method header
    int result = num1 > num2 ? num1 : num2;    // method body: phần trong {}
    return result;                             // return value
}

int z = max(x, y);                             // x, y là argument
Thuật ngữ Nghĩa Trong ví dụ
Method header (phần đầu) modifier, kiểu trả về, tên, danh sách tham số public static int max(int num1, int num2)
Method body (thân hàm) các lệnh trong {} hai dòng bên trong
Formal parameter (tham số, gọi tắt parameter) biến khai báo trong header num1, num2
Actual parameter / argument (đối số) giá trị truyền vào lúc gọi; được sao chép vào parameter, nên Java truyền tham trị x, y
Method signature tên + danh sách kiểu tham số max(int, int)
Return value giá trị return gửi về chỗ gọi gán vào z

Call stack và stack frame

Mỗi lần gọi hàm, JVM đẩy một stack frame (khung chứa tham số, biến cục bộ và địa chỉ để quay về) lên stack của thread hiện tại. Hàm chạy xong thì frame bị lấy ra. Giống chồng đĩa: đĩa đặt vào sau cùng được lấy ra trước tiên (LIFO, last in first out).

sequenceDiagram
  participant main
  participant total
  participant tax
  main->>total: total(items)  [push frame total]
  total->>tax: tax(subtotal)  [push frame tax]
  tax-->>total: return 8.0    [pop frame tax]
  total-->>main: return 108.0 [pop frame total]

Hệ quả thực tế:

  • Mỗi thread có stack riêng (mặc định khoảng 512 KB – 1 MB, chỉnh bằng -Xss). Đệ quy quá sâu ném StackOverflowError.
  • Biến cục bộ nằm trên stack nên mỗi thread có bản riêng, không cần đồng bộ. Object nằm trên heap và có thể bị nhiều thread dùng chung.
  • Trong stack trace của exception, dòng trên cùng là frame được đẩy vào sau cùng.
  • Từ Java 21, virtual thread (thread nhẹ do JVM quản lý) lưu stack trên heap, nên tạo được hàng triệu thread. Mô hình frame vẫn như trên.

Phạm vi của biến (scope)

  • Biến cục bộ chỉ sống trong hàm (hoặc khối {}) khai báo ra nó; hàm khác không nhìn thấy.
  • Tham số thực chất là biến cục bộ, được gán giá trị lúc gọi hàm.
  • Biến khai báo trong for (int i...) hoặc trong thân vòng lặp chỉ sống trong vòng lặp đó, nên hai vòng tách rời đều dùng được tên i.
  • Java không cho đặt trùng tên biến cục bộ đang còn trong phạm vi: không khai báo i trong vòng lặp nếu phía trên đã có biến cục bộ i. Nhưng i khai báo sau vòng lặp thì hợp lệ, vì i của vòng lặp đã hết phạm vi.
static void demo() {
    for (int i = 0; i < 3; i++) { }
    for (int i = 0; i < 3; i++) { }   // OK: phạm vi tách rời
    int i = 10;                       // OK: biến i của hai vòng lặp đã hết phạm vi
    // for (int i = 0; ...) { }       // LỖI: i đã tồn tại trong phạm vi này
}

Biến cục bộ được lambda hoặc anonymous class dùng phải là effectively final, tức là chỉ được gán đúng một lần.

Java luôn truyền tham trị (pass-by-value)

flowchart LR
  subgraph main
    d[data: ref]
  end
  subgraph reassign
    p[arr: bản sao của ref]
  end
  H1[(mảng 20, 10)]
  H2[(mảng mới 0, 0)]
  d --> H1
  p -. trước khi gán .-> H1
  p --> H2

Bài tập

Đề được viết lại ngắn gọn theo cách của mình. Code đã chạy thử trên JDK 21.

Vòng lặp và hàm

1. Nhập số cho tới khi gặp 0 thì dừng, rồi in tổng.

2. Đố cộng: chương trình sinh ngẫu nhiên hai số, hỏi tổng cho tới khi người dùng trả lời đúng.

Lời giải bài 1–2
Scanner in = new Scanner(System.in);
long sum = 0;
int n;
do {
    n = Integer.parseInt(in.nextLine().trim());
    sum += n;
} while (n != 0);
System.out.println("Tổng = " + sum);

do-while hợp ở bài 1 vì luôn phải đọc ít nhất một số. Cộng thêm số 0 cuối cùng không làm thay đổi tổng.

var random = java.util.concurrent.ThreadLocalRandom.current();
int a = random.nextInt(1, 100), b = random.nextInt(1, 100);
Scanner in = new Scanner(System.in);
int attempts = 0;
while (true) {
    System.out.printf("%d + %d = ? ", a, b);
    attempts++;
    if (Integer.parseInt(in.nextLine().trim()) == a + b) break;
    System.out.println("Sai rồi, thử lại.");
}
System.out.println("Đúng sau " + attempts + " lần.");

3. In bảng cửu chương đầy đủ dạng lưới 9×9: một dòng tiêu đề, hàng số 1 … 9 ở trên cùng, một đường kẻ ngang, rồi 9 hàng dạng i | theo sau là i×1 … i×9. Lệnh in trong cùng chạy 9 × 9 = 81 lần, O(n²).

Câu hỏi kèm theo trên slide: với for (int i = 0; i < 10; i++) lồng for (int j = 0; j < i; j++), lệnh in trong cùng chạy bao nhiêu lần? Vòng trong chạy 0, 1, …, 9 lần, nên tổng là 0 + 1 + … + 9 = 45, đúng bằng số ô của bảng tam giác ở phần vòng lặp lồng nhau.

Lời giải bài 3: bảng cửu chương 9×9 và cách senior cải thiện
static void printTable(int n) {
    System.out.println("Multiplication Table");
    System.out.print("    ");                       // chừa chỗ cho cột nhãn "i | "
    for (int j = 1; j <= n; j++) System.out.printf("%4d", j);
    System.out.println();
    System.out.println("-".repeat(4 + 4 * n));
    for (int i = 1; i <= n; i++) {
        System.out.printf("%d | ", i);
        for (int j = 1; j <= n; j++) System.out.printf("%4d", i * j);
        System.out.println();
    }
}
// printTable(9);
Multiplication Table
       1   2   3   4   5   6   7   8   9
----------------------------------------
1 |    1   2   3   4   5   6   7   8   9
2 |    2   4   6   8  10  12  14  16  18
3 |    3   6   9  12  15  18  21  24  27
4 |    4   8  12  16  20  24  28  32  36
5 |    5  10  15  20  25  30  35  40  45
6 |    6  12  18  24  30  36  42  48  54
7 |    7  14  21  28  35  42  49  56  63
8 |    8  16  24  32  40  48  56  64  72
9 |    9  18  27  36  45  54  63  72  81

%4d căn phải mỗi số trong 4 ô, nên các cột thẳng hàng dù số có một hay hai chữ số. Hàng tiêu đề bắt đầu bằng 4 dấu cách, đúng bằng độ rộng nhãn "i | ", để số 1 … 9 nằm ngay trên cột của chúng.

Senior sẽ cải thiện:

  • Tính độ rộng cột từ giá trị lớn nhất (String.valueOf(n * n).length() + 1) và cả độ rộng nhãn, vì với n ≥ 10 nhãn "10 | " dài hơn và các cột sẽ lệch.
  • Tách phần dựng bảng thành hàm trả về String (dùng StringBuilder) để viết unit test được, còn phần in ra console để ở ngoài.

4. Ước chung lớn nhất của hai số (16 và 24 ra 8). Thuật toán Euclid: gcd(a, b) = gcd(b, a mod b), dừng khi b = 0. Độ phức tạp O(log min(a, b)); “thử từng số từ min(a, b) giảm dần” là O(n), chậm hơn hẳn khi số có 9 chữ số.

5. Chuỗi palindrome (đọc xuôi và ngược như nhau): noon và et4554te là true, ronin là false. Dùng hai con trỏ (một chỉ số chạy từ đầu, một từ cuối, tiến vào giữa): O(n) thời gian, O(1) bộ nhớ.

6. In 50 số nguyên tố đầu tiên. Slide ghi ví dụ “1, 2, 3, 5…”, nhưng 1 không phải số nguyên tố. Số nguyên tố phải lớn hơn 1 và chỉ có hai ước là 1 và chính nó. Cần mọi số nguyên tố nhỏ hơn N lớn thì dùng sàng Eratosthenes, O(N log log N).

7. Đổi hệ 16 sang hệ 10. Duyệt từ trái sang phải, mỗi bước result = result * 16 + digit (thuật toán Horner). Đi làm thì dùng sẵn Integer.parseInt("1A", 16); tự viết để hiểu thuật toán.

Lời giải bài 4–7: gcd, palindrome, số nguyên tố, hex
static long gcd(long a, long b) {
    a = Math.abs(a); b = Math.abs(b);
    while (b != 0) {
        long t = a % b;
        a = b;
        b = t;
    }
    return a;
}
static boolean isPalindrome(String s) {
    for (int i = 0, j = s.length() - 1; i < j; i++, j--) {
        if (s.charAt(i) != s.charAt(j)) return false;
    }
    return true;
}

Cách new StringBuilder(s).reverse().toString().equals(s) ngắn hơn nhưng tốn thêm O(n) bộ nhớ.

static boolean isPrime(int n) {
    if (n < 2) return false;
    if (n % 2 == 0) return n == 2;
    for (int d = 3; (long) d * d <= n; d += 2) {   // ép long để d*d không tràn
        if (n % d == 0) return false;
    }
    return true;
}

static int[] firstPrimes(int count) {
    int[] primes = new int[count];
    int found = 0;
    for (int n = 2; found < count; n++) {
        if (isPrime(n)) primes[found++] = n;
    }
    return primes;   // 2, 3, 5, 7, 11, ..., 229
}
static int hexToDecimal(String hex) {
    int result = 0;
    for (char c : hex.toUpperCase().toCharArray()) {
        int digit;
        if (c >= '0' && c <= '9') digit = c - '0';
        else if (c >= 'A' && c <= 'F') digit = c - 'A' + 10;
        else throw new IllegalArgumentException("Ký tự hex không hợp lệ: " + c);
        result = result * 16 + digit;
    }
    return result;   // "1A" -> 26, "FF" -> 255
}

8. ƯCLN và BCNN của nhiều cặp số (mỗi số tối đa 9 chữ số; dòng đầu là số bộ test). Mẫu: input 2 / 12 34 / 1234 5678 cho output 2 204 / 2 3503326.

9. Đếm số ước chẵn của N (N ≤ 10⁹, tối đa 100 test). Duyệt từ 1 tới N là 10⁹ × 100 phép tính, quá chậm. Nhận xét: N lẻ thì không có ước chẵn. N chẵn thì mỗi ước chẵn có dạng 2k, với k là ước của N/2, nên chỉ cần đếm ước của N/2, mất O(√N). Mẫu: N = 9 cho 0 (9 lẻ), N = 8 cho 3 (các ước chẵn 2, 4, 8).

Lời giải bài 8–9: đọc nhiều test nhanh và đếm ước chẵn
public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(br.readLine().trim());
    StringBuilder out = new StringBuilder();
    while (t-- > 0) {
        StringTokenizer st = new StringTokenizer(br.readLine());
        long a = Long.parseLong(st.nextToken()), b = Long.parseLong(st.nextToken());
        out.append(gcd(a, b)).append(' ').append(lcm(a, b)).append('\n');
    }
    System.out.print(out);   // gom output rồi in một lần, nhanh hơn nhiều so với println từng dòng
}
static int countEvenDivisors(int n) {
    if (n % 2 != 0) return 0;
    int m = n / 2, count = 0;
    for (int d = 1; (long) d * d <= m; d++) {
        if (m % d == 0) count += (d == m / d) ? 1 : 2;
    }
    return count;
}

Mình đã đối chiếu countEvenDivisors với cách vét cạn cho mọi n < 500.

Bài tập vòng lặp từ tài liệu Hỏi Dân IT

Năm bài ngắn: tổng 1 tới 100 bằng for, in số chẵn từ 2 tới 20 bằng while, hỏi mật khẩu bằng do-while cho tới khi đúng, tìm số đầu tiên chia hết cho 7 trong 1..100 bằng break, in các số chẵn từ 1 tới 10 bằng continue.

  • Đính chính tài liệu gốc: vòng lặp if (i == 5) break; được chú thích in ra 1 2 4 5. Đúng ra là 1 2 3 4, vì break dừng trước khi in 5. 1 2 4 5 là kết quả của ví dụ continue bỏ qua 3.
  • Hệ thống thật không bao giờ so sánh mật khẩu dạng chữ: lưu hash (bcrypt, Argon2) rồi để thư viện kiểm tra.
Lời giải năm bài vòng lặp ngắn
int sum = 0;
for (int i = 1; i <= 100; i++) sum += i;              // 5050, cũng bằng 100 * 101 / 2

int even = 2;
while (even <= 20) { System.out.print(even + " "); even += 2; }

Scanner in = new Scanner(System.in);
String input;
do {
    System.out.print("Mật khẩu: ");
    input = in.nextLine();
} while (!"secret".equals(input));                     // so sánh nội dung bằng equals, không dùng ==
System.out.println("Đăng nhập thành công!");

for (int i = 1; i <= 100; i++) {
    if (i % 7 == 0) { System.out.println(i); break; }  // 7
}

for (int i = 1; i <= 10; i++) {
    if (i % 2 != 0) continue;                          // bỏ số lẻ
    System.out.print(i + " ");                         // 2 4 6 8 10
}

Lab 02: quản lý điểm số

Đề (viết lại):

  1. Cho người dùng nhập liên tục điểm từ 0 tới 10 bằng do-while; điểm ngoài khoảng thì báo lỗi và bỏ qua bằng continue; nhập -1 thì dừng. Cộng dồn tổng và đếm số điểm.
  2. Sau đó hiện menu bằng switch: 1 in điểm trung bình làm tròn 2 chữ số; 2 xếp loại học lực (từ 9: Xuất sắc, từ 8: Giỏi, từ 6,5: Khá, từ 5: Trung bình, dưới 5: Yếu); 3 thoát bằng return.

Ba điểm cần để ý:

  • continue trong do-while nhảy tới điều kiện while (score != STOP), không quay lại đầu thân vòng lặp. Nhập -1 thì điều kiện sai, vòng lặp kết thúc mà không cộng -1 vào tổng.
  • Trường hợp biên: nhập -1 ngay từ đầu thì count == 0; chia cho 0 với double ra NaN, nên phải kiểm tra trước. Menu nằm trong vòng lặp để chọn được nhiều lần.
  • Senior sẽ cải tiến: tách classify và phép tính trung bình ra để unit test (cả các giá trị biên 5; 6,5; 8; 9), dùng enum cho học lực thay vì chuỗi, và không gọi return sâu trong main khi chương trình lớn dần: để main chỉ điều phối, logic nằm ở các hàm trả về giá trị.
Lời giải Lab 02 và kết quả chạy thử
import java.util.Scanner;

public class Lab02 {
    static final double STOP = -1;

    static String classify(double average) {
        if (average >= 9) return "Xuất sắc";
        else if (average >= 8) return "Giỏi";
        else if (average >= 6.5) return "Khá";
        else if (average >= 5) return "Trung bình";
        else return "Yếu";
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        double sum = 0;
        int count = 0;
        double score;

        // Tính năng 1: nhập điểm cho tới khi gặp -1
        do {
            System.out.print("Nhập điểm (0-10, -1 để dừng): ");
            String raw = in.nextLine().trim();
            try {
                score = Double.parseDouble(raw);
            } catch (NumberFormatException e) {
                score = Double.NaN;                 // chữ cái, chuỗi rỗng... coi như không hợp lệ
            }
            if (score == STOP) continue;            // continue nhảy tới điều kiện while, điều kiện sai nên dừng
            if (!(score >= 0 && score <= 10)) {     // viết như vậy để NaN cũng rơi vào nhánh này
                System.out.println("Điểm không hợp lệ. Nhập lại.");
                continue;
            }
            sum += score;
            count++;
        } while (score != STOP);

        // Tính năng 2: menu
        while (true) {
            System.out.println("===== MENU =====");
            System.out.println("1. Tính điểm trung bình");
            System.out.println("2. Phân loại học lực");
            System.out.println("3. Thoát");
            System.out.print("Lựa chọn: ");
            switch (in.nextLine().trim()) {
                case "1" -> {
                    if (count == 0) System.out.println("Chưa có điểm nào.");
                    else System.out.printf("Điểm trung bình: %.2f%n", sum / count);
                }
                case "2" -> {
                    if (count == 0) System.out.println("Chưa có điểm nào.");
                    else System.out.println("Học lực: " + classify(sum / count));
                }
                case "3" -> {
                    System.out.println("Tạm biệt!");
                    return;                         // kết thúc main, cũng là kết thúc chương trình
                }
                default -> System.out.println("Lựa chọn không hợp lệ.");
            }
        }
    }
}

Chạy với input 9, 5, -3, 11, abc, 8.5, -1 rồi chọn 1, 2, 7, 3: ba giá trị -3, 11, abc bị từ chối, trung bình là 7.50, xếp loại Khá, lựa chọn 7 bị báo không hợp lệ, 3 thoát.

Ghi nhớ

  • Giải thích được while, do-while, for khác nhau ở đâu và khi nào dùng cái nào.
  • Biết sau continue thì for và while nhảy tới đâu, và vì sao while có thể lặp vô hạn.
  • Vẽ được call stack khi main gọi total gọi tax, và nói được khi nào gặp StackOverflowError.
  • Chứng minh được Java chỉ pass-by-value bằng ví dụ swapFirstTwo và reassign.
  • Biết vì sao BCNN phải viết a / gcd * b thay vì a * b / gcd.

Câu hỏi phỏng vấn

Junior

while, do-while và for khác nhau thế nào?

while kiểm tra trước nên có thể chạy 0 lần; do-while chạy trước nên luôn chạy ít nhất 1 lần; for gom khởi tạo, điều kiện và cập nhật vào một dòng.

for hợp khi biết trước số lần lặp. for-each dùng để duyệt mảng hoặc Iterable khi không cần chỉ số.

break và continue khác nhau thế nào? Sau continue trong vòng for thì chuyện gì xảy ra?

break thoát hẳn vòng lặp gần nhất (hoặc vòng có nhãn); continue chỉ bỏ phần còn lại của lượt hiện tại.

Trong for, sau continue thì lệnh cập nhật (i++) chạy trước rồi mới kiểm tra điều kiện. Trong while/do-while thì nhảy thẳng tới chỗ kiểm tra điều kiện.

return, break và System.exit khác nhau thế nào?

break thoát vòng lặp, return thoát method, System.exit dừng cả JVM.

  • break chỉ thoát vòng lặp (hoặc switch) gần nhất; code sau vòng lặp vẫn chạy.
  • return kết thúc method hiện tại và trả quyền điều khiển cho nơi gọi. return trong main kết thúc thread chính; chương trình dừng nếu không còn thread non-daemon nào.
  • System.exit(code) dừng ngay JVM với mã thoát cho hệ điều hành, bỏ qua các khối finally đang dở. Ứng dụng server hay thư viện gần như không bao giờ gọi nó.
Parameter và argument khác nhau thế nào?

Parameter là biến khai báo trong header của method; argument là giá trị cụ thể truyền vào lúc gọi.

Ví dụ num1, num2 trong int max(int num1, int num2) là parameter (formal parameter); x, y trong max(x, y) là argument (actual parameter). Khi gọi, giá trị của argument được sao chép vào parameter, và parameter sống như một biến cục bộ trong stack frame của method.

Mid

Java là pass-by-value hay pass-by-reference?

Luôn là pass-by-value; với object, giá trị được sao chép là tham chiếu (địa chỉ).

Vì vậy hàm sửa được nội dung object mà caller đang trỏ tới, nhưng gán lại tham số sang object khác thì không ảnh hưởng gì tới biến của caller.

Stack và heap khác nhau thế nào? StackOverflowError và OutOfMemoryError xảy ra khi nào?

Stack riêng cho từng thread, chứa frame của các lời gọi; heap dùng chung, chứa object và do GC dọn.

  • Frame trên stack chứa biến cục bộ và tham số, được giải phóng ngay khi hàm trả về.
  • StackOverflowError: đệ quy quá sâu hoặc không có điểm dừng.
  • OutOfMemoryError: Java heap space: object còn được tham chiếu vượt quá -Xmx, thường do rò rỉ bộ nhớ (cache không giới hạn, listener không gỡ ra).
Effectively final là gì? Vì sao lambda chỉ dùng được biến cục bộ effectively final?

Effectively final là biến không khai báo final nhưng chỉ được gán đúng một lần. Lambda chỉ sao chép giá trị biến cục bộ, nên compiler cấm gán lại để bản sao và bản gốc không lệch nhau.

Biến cục bộ nằm trên stack frame và có thể biến mất trước khi lambda chạy (ví dụ lambda chạy trên thread khác), nên lambda và anonymous class phải sao chép giá trị vào trong. Nếu cho gán lại, bản sao và biến gốc sẽ lệch nhau, gây bug khó hiểu. Field không bị giới hạn này vì lambda giữ this chứ không sao chép field.

Senior

Đệ quy so với vòng lặp: khi nào nên chuyển đệ quy sang vòng lặp trong Java?

Khi độ sâu đệ quy tăng theo kích thước input, vì Java không tối ưu đệ quy đuôi (tail-call) và mỗi lời gọi tốn thêm một frame.

Duyệt danh sách liên kết dài hay cây lệch về một phía có thể làm tràn stack. Khi đó chuyển sang vòng lặp với stack hoặc queue tự quản lý (ArrayDeque). Đệ quy vẫn ổn khi độ sâu là O(log n), như duyệt cây cân bằng hay chia để trị.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng khi phỏng vấn
infinite loop /ˈɪnfɪnət luːp/ vòng lặp vô hạn “The bug was an infinite loop because the counter was never incremented.”
off-by-one error lỗi lệch một đơn vị “Using <= instead of < caused an off-by-one error.”
nested loop /ˈnestɪd/ vòng lặp lồng nhau “Two nested loops give quadratic time complexity.”
call stack /kɔːl stæk/ ngăn xếp lời gọi hàm “Each method call pushes a new frame onto the call stack.”
stack frame khung chứa biến cục bộ của một lời gọi “Local variables live in the stack frame of the current method.”
scope /skoʊp/ phạm vi của biến “A loop variable goes out of scope when the loop ends.”
pass-by-value truyền tham trị “Java is strictly pass-by-value; for objects, the reference itself is copied.”
side effect /saɪd ɪˈfekt/ tác dụng phụ (sửa trạng thái bên ngoài) “A method that mutates its input array has a hidden side effect.”
time complexity /kəmˈpleksəti/ độ phức tạp thời gian “The sieve reduces the time complexity to O(n log log n).”
sentinel value /ˈsentɪnl/ giá trị đánh dấu kết thúc input “The loop stops when the user enters the sentinel value -1.”
early return /ˈɜːrli rɪˈtɜːrn/ thoát hàm sớm “An early return for invalid input keeps the main logic unindented.”
parameter / argument /pəˈræmɪtər/ /ˈɑːrɡjumənt/ tham số (khai báo) / đối số (lúc gọi) “The method declares two parameters, and the caller passes two arguments.”

Phần lớn hình minh hoạ trong slide lấy từ sách Introduction to Java Programming and Data Structures (Y. Daniel Liang, bản 11), một tài liệu tốt nếu muốn đọc thêm.


Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer) và tài liệu Java Core của Hỏi Dân IT, cộng thêm kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.