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
Biến chỉ chứa dữ liệu; toán tử và câu điều kiện mới quyết định chương trình làm gì với nó, và đây là chỗ câu đố phỏng vấn hay nhắm tới: x = x++, Integer so bằng ==, short s = s + 1, ba ngôi ném NullPointerException. Đọc xong, bạn tính tay được phép bit, tránh được các bẫy đó và chọn đúng giữa if và switch. Nên đọc trước biến và kiểu dữ liệu; bài tiếp theo là vòng lặp và hàm.
Sơ đồ tóm tắt:
mindmap
root((Toán tử và rẽ nhánh))
Số học
Chia nguyên cắt về 0
Số dư mang dấu số bị chia
Tràn số quay vòng
== trên object so địa chỉ
&& và || ngắn mạch
a++ trả giá trị cũ
Rẽ nhánh
if: điều kiện bất kỳ
switch: giá trị cụ thể
1. Toán tử
Ý chính: toán tử Java chạy trên kiểu cụ thể (int 32 bit, object là tham chiếu), nên kết quả đôi khi khác toán trên giấy. Phần lớn bẫy nằm ở chia nguyên, == trên object, ++ và tràn số.
Số học và gán
int a = 17, b = 5;
a + b; // 22
a - b; // 12
a * b; // 85
a / b; // 3 (chia nguyên)
a % b; // 2 (phần dư)
-17 / 5; // -3 (cắt về phía 0)
-17 % 5; // -2 (dấu của phần dư theo số bị chia)
Math.floorMod(-17, 5); // 3, hữu ích khi tính chỉ số vòng tròn hoặc hash bucket
int x = 10;
x += 3; // x = x + 3 -> 13
x -= 1; // 12
x *= 2; // 24
x /= 5; // 4
x %= 3; // 1
Toán tử gán kép (+=, *=…) có ép kiểu ngầm: short s = 1; s += 5; biên dịch được, còn s = s + 5; thì không, vì s + 5 có kiểu int. Khi tính toán, byte, short, char luôn được nâng lên int trước.
So sánh và logic
| Toán tử | Ý nghĩa |
|---|---|
==, != |
bằng, khác |
>, >=, <, <= |
lớn hơn, lớn hơn hoặc bằng, nhỏ hơn, nhỏ hơn hoặc bằng |
&& |
VÀ, ngắn mạch: vế trái false thì không xét vế phải |
|| |
HOẶC, ngắn mạch: vế trái true thì không xét vế phải |
! |
phủ định |
int score = 72;
boolean passed = score >= 50; // true
boolean excellent = score >= 90 && passed; // false
boolean retry = !passed || score < 75; // true
// Ngắn mạch giúp tránh NullPointerException:
if (user != null && user.isActive()) { ... }
Tăng/giảm: tiền tố và hậu tố
Biểu thức (ban đầu a = 5) |
Thứ tự thực hiện | Kết quả |
|---|---|---|
b = a++ |
gán b = a trước, rồi mới tăng a |
b = 5, a = 6 |
b = ++a |
tăng a trước, rồi mới gán |
a = 6, b = 6 |
b = a-- |
gán trước, giảm sau | b = 5, a = 4 |
b = --a |
giảm trước, gán sau | a = 4, b = 4 |
Đứng một mình (a++; hoặc ++a;) thì hai cách như nhau. Câu đố hay gặp: int x = 5; x = x++; thì x vẫn bằng 5. Giá trị cũ được tính ra trước, x tăng lên 6, rồi giá trị cũ lại được gán đè vào x.
Slide có một comment sai: ví dụ g = f-- được chú thích là “f = f - 1; g = f”. Đúng ra là g = f; rồi mới f = f - 1 (output in ra g : 2, f : 1 mới là đúng).
Bit, byte và hệ nhị phân
- 1 byte = 8 bit. Viết
blà bit,Blà byte. Mạng 100 Mbps tức là 100 megabit/giây, khoảng 12,5 MB/giây. - Tiền tố SI: 1 KB = 1000 B. Tiền tố nhị phân: 1 KiB = 1024 B. RAM và
-Xmx512mcủa JVM dùng hệ 1024. Slide chỉ nêu 1 KB = 1000 B, mới là một nửa câu chuyện.
Nhị phân sang thập phân: nhân từng bit với luỹ thừa của 2 theo vị trí (đếm từ phải, bắt đầu từ 0) rồi cộng lại: 1101₂ = 8 + 4 + 0 + 1 = 13.
Thập phân sang nhị phân: chia liên tục cho 2, ghi số dư, rồi đọc số dư từ dưới lên: 13 → 6 dư 1 → 3 dư 0 → 1 dư 1 → 0 dư 1, được 1101.
Thêm ví dụ đổi hệ cơ số: 1101₂, 1010₂, 11011011₂ và 47
Viết đủ các luỹ thừa: 1101₂ = 1·2³ + 1·2² + 0·2¹ + 1·2⁰ = 8 + 4 + 0 + 1 = 13.
Câu đố trên slide, 1010₂ bằng bao nhiêu: 0·2⁰ + 1·2¹ + 0·2² + 1·2³ = 0 + 2 + 0 + 8 = 10. Một ví dụ dài hơn: 11011011₂ = 128 + 64 + 16 + 8 + 2 + 1 = 219 (bỏ qua các vị trí có bit 0, tức 32 và 4).
Với 47: 47 → 23 dư 1 → 11 dư 1 → 5 dư 1 → 2 dư 1 → 1 dư 0 → 0 dư 1, đọc từ dưới lên được 101111₂. Kiểm tra lại: 32 + 8 + 4 + 2 + 1 = 47.
Toán tử ba ngôi, instanceof, bit
String label = stock > 0 ? "Còn hàng" : "Hết hàng";
Object o = "hello";
if (o instanceof String s && s.length() > 3) { // pattern matching, Java 16+
System.out.println(s.toUpperCase());
}
int flags = 0b0101;
flags & 0b0100; // AND: kiểm tra bit
flags | 0b0010; // OR: bật bit
flags ^ 0b0001; // XOR: đảo bit
~flags; // NOT
1 << 10; // 1024, dịch trái = nhân với 2^n
-16 >> 2; // -4, dịch phải giữ dấu
-16 >>> 28; // 15, dịch phải không giữ dấu (chèn 0 vào bên trái)
Toán tử bit gặp ở bitmask quyền (permission), feature flag, hàm băm (HashMap dùng h ^ (h >>> 16)), hoặc kiểm tra luỹ thừa của 2: (n & (n - 1)) == 0.
Toán tử bit xử lý từng cặp bit ở cùng vị trí: & ra 1 khi cả hai bit là 1, | khi có ít nhất một bit 1, ^ khi hai bit khác nhau. Với 5 = 0101 và 3 = 0011: 5 & 3 = 1, 5 | 3 = 7, 5 ^ 3 = 6, 5 << 2 = 20, 5 >> 2 = 1, ~5 = -6.
Tính tay với a = 5, b = 3: bảng chân trị và phép dịch
Viết ra nhị phân (chỉ ghi 4 bit cuối, các bit phía trước đều là 0): 5 = 0101, 3 = 0011. Bảng chân trị:
| bit x | bit y | x & y |
x | y |
x ^ y |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
0101 (5) 0101 (5) 0101 (5)
& 0011 (3) | 0011 (3) ^ 0011 (3)
---- ---- ----
0001 = 1 0111 = 7 0110 = 6
5 << 2: dịch trái 2 bit,0101thành010100= 20, tức5 · 2².5 >> 2: dịch phải 2 bit,0101thành0001= 1, tức5 / 2²làm tròn xuống. Chỗ trống bên trái được lấp bằng bit dấu: số dương lấp 0, số âm lấp 1, nên-20 >> 2 == -5. Toán tử>>>thì luôn lấp 0.~5 == -6: xem pitfall ngay dưới.
Thứ tự ưu tiên (rút gọn)
() > hậu tố a++ > tiền tố ++a, !, ép kiểu > * / % > + - > << >> > < > instanceof > == != > & > ^ > | > && > || > ?: > = và +=…
Không chắc thì cứ thêm ngoặc. Ví dụ hay bị hỏi: "" + 1 + 2 cho ra "12", còn 1 + 2 + "" cho ra "3", vì phép + đi từ trái sang phải.
2. Rẽ nhánh
Ý chính: if dùng cho điều kiện bất kỳ, kể cả khoảng giá trị; switch so khớp giá trị hoặc kiểu cụ thể. Code mới nên dùng switch expression vì nó không lọt case và compiler kiểm tra đủ trường hợp.
if / else if / else
static String classify(int temperature) {
if (temperature < 0) {
return "Đóng băng";
} else if (temperature < 25) {
return "Mát";
} else {
return "Nóng";
}
}
Điều kiện được xét lần lượt từ trên xuống, chỉ một nhánh chạy. Code thực tế hay dùng guard clause (điều kiện thoát sớm): gặp trường hợp không hợp lệ thì return hoặc throw ngay đầu hàm để code đỡ lồng nhiều tầng.
static BigDecimal discount(Order order) {
if (order == null) throw new IllegalArgumentException("order is required");
if (!order.isPaid()) return BigDecimal.ZERO;
// phần logic chính không phải lồng trong if nào
return order.total().multiply(new BigDecimal("0.05"));
}
Toán tử ba ngôi
Dùng cho phép chọn ngắn gọn giữa hai giá trị. Đừng lồng ba ngôi, rất khó đọc.
switch: cổ điển và hiện đại
Cách viết cổ điển, mỗi case phải có break. Quên break là code chạy lọt (fall-through) xuống case bên dưới:
int month = 4;
int days;
switch (month) {
case 2:
days = 28;
break;
case 4: case 6: case 9: case 11: // gộp các case có cùng xử lý
days = 30;
break;
default:
days = 31;
}
Switch expression (Java 14+; ở Java 12–13 mới là bản preview, nên tài liệu ghi “từ Java 12” là chưa chính xác) dùng mũi tên, không lọt case và trả về giá trị. Khi switch trên enum hoặc sealed type (kiểu chỉ cho phép một danh sách lớp con cố định), compiler bắt buộc xử lý hết các trường hợp:
String dayName = switch (day) {
case 1 -> "Chủ nhật";
case 2, 3, 4, 5, 6, 7 -> "Thứ " + day;
default -> throw new IllegalArgumentException("Ngày không hợp lệ: " + day);
};
Kiểu được switch: byte, short, char, int cùng wrapper của chúng, String, enum, và từ Java 21 là bất kỳ kiểu tham chiếu nào (khi dùng pattern). long, float, double, boolean không dùng được ở switch cổ điển. Nhãn case phải là hằng số lúc biên dịch.
Slide ghi “var” trong danh sách kiểu, nhưng var không phải kiểu: nó chỉ là biến có kiểu được suy ra từ một trong các kiểu trên.
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.
Nhóm 3: toán tử và điều kiện
3.1. Khai báo một String rồi in ra: String course = "Backend"; System.out.println(course);.
3.2. Một số nguyên là chẵn hay lẻ, âm hay dương; mỗi kết luận in trên một dòng.
3.3. Tổng, hiệu, tích, thương của hai số nguyên; phép chia phải ép kiểu và kiểm tra mẫu khác 0.
3.4. So sánh hai số: Integer.compare(a, b) trả về số âm, 0 hoặc số dương; sau đó dùng if/else if/else để in “a lớn hơn”, “b lớn hơn” hoặc “bằng nhau”.
3.5. Chu vi và diện tích hình chữ nhật cạnh a, b: 2 * (a + b) và a * b. Nên kiểm tra a > 0 && b > 0 trước.
3.6. Ba số thực có tạo thành tam giác không (in YES/NO).
3.7. Đổi thập phân ↔ nhị phân, dùng đúng thuật toán “chia 2 lấy dư” và “nhân 2 cộng bit” ở phần “Bit, byte và hệ nhị phân” phía trên.
Lời giải nhóm 3: 3.2, 3.3, 3.6, 3.7
3.2.
static String describeNumber(int n) {
String parity = n % 2 == 0 ? "chẵn" : "lẻ"; // dùng n % 2 != 0 cho lẻ; n % 2 == 1 sai với số âm
String sign = n > 0 ? "dương" : n < 0 ? "âm" : "bằng 0";
return parity + "\n" + sign;
}
Bẫy: -7 % 2 == -1 chứ không phải 1, nên kiểm tra lẻ bằng n % 2 == 1 sẽ sai với số âm.
3.3.
static void arithmetic(int a, int b) {
System.out.println("Tổng: " + ((long) a + b)); // ép long để tránh tràn
System.out.println("Hiệu: " + ((long) a - b));
System.out.println("Tích: " + ((long) a * b));
if (b == 0) {
System.out.println("Không chia được cho 0");
} else {
System.out.println("Thương: " + (double) a / b); // ép trước khi chia
}
}
(double) a / b khác với (double) (a / b). Cách thứ hai chia nguyên xong rồi mới ép, nên vẫn mất phần lẻ.
3.6.
static boolean isTriangle(double a, double b, double c) {
return a > 0 && b > 0 && c > 0 && a + b > c && a + c > b && b + c > a;
}
System.out.println(isTriangle(3, 4, 5) ? "YES" : "NO");
3.7.
static String toBinary(int n) {
if (n == 0) return "0";
StringBuilder sb = new StringBuilder();
while (n > 0) { sb.append(n % 2); n /= 2; }
return sb.reverse().toString();
}
static int fromBinary(String bits) {
int result = 0;
for (char c : bits.toCharArray()) {
if (c != '0' && c != '1') throw new IllegalArgumentException("Không phải bit: " + c);
result = result * 2 + (c - '0');
}
return result;
}
Nhóm 4: bài tập điều kiện từ tài liệu Hỏi Dân IT
4.1. Xếp loại học lực theo điểm trung bình (thang 10). Từ 9 trở lên là Xuất sắc, từ 8 là Giỏi, từ 6,5 là Khá, từ 5 là Trung bình, dưới 5 là Yếu, ngoài [0, 10] là không hợp lệ.
4.2. Nhập số từ 1 tới 7, in tên thứ trong tuần (1 là Monday), ngoài khoảng thì in Invalid day number!.
Lời giải nhóm 4: 4.1 và 4.2
4.1.
static String grade(double score) {
if (!(score >= 0 && score <= 10)) return "Không hợp lệ"; // bắt được cả NaN
if (score >= 9) return "Xuất sắc";
if (score >= 8) return "Giỏi";
if (score >= 6.5) return "Khá";
if (score >= 5) return "Trung bình";
return "Yếu";
}
// 9.0 -> Xuất sắc, 8.99 -> Giỏi, 4.9 -> Yếu, 11 -> Không hợp lệ
Bảng gốc ghi các khoảng như “8,0 – 9,0” và “9,0 – 10,0”, nên điểm 9,0 thuộc khoảng nào là không rõ. Khi viết điều kiện, luôn chốt mỗi khoảng là nửa mở ([8, 9)); xét từ trên xuống thì mỗi if chỉ cần một cận dưới.
4.2.
static String dayName(int day) {
return switch (day) {
case 1 -> "Monday";
case 2 -> "Tuesday";
case 3 -> "Wednesday";
case 4 -> "Thursday";
case 5 -> "Friday";
case 6 -> "Saturday";
case 7 -> "Sunday";
default -> "Invalid day number!";
};
}
Code thật thì dùng java.time.DayOfWeek.of(day): nó dùng đúng quy ước 1 = Monday theo ISO-8601 và ném DateTimeException khi ngoài khoảng, nên không phải tự viết bảng.
Ghi nhớ
- Giải thích được vì sao
-7 % 2 == -1và khi nào cầnMath.floorMod. - Giải thích được vì sao
Integer127 so==ratruecòn 128 rafalse. - Tính tay được
5 & 3,5 >> 2,~5, và nói được vì sao~5là số âm. - Biết vì sao
count++không an toàn giữa nhiều thread và dùng gì thay. - Biết khi nào dùng
if, khi nào dùng switch expression, khi nào chuyển sang đa hình.
Câu hỏi phỏng vấn
Junior
7 / 2, 7 % -2, -7 / 2 lần lượt bằng bao nhiêu?
3, 1, -3.
Chia nguyên cắt về phía 0, dấu của phần dư theo số bị chia. Muốn chia lấy dư luôn không âm thì dùng Math.floorMod.
a++ và ++a khác nhau thế nào?
a++ trả về giá trị trước khi tăng, ++a trả về giá trị sau khi tăng.
Cả hai đều tăng a thêm 1. Chỉ khác nhau khi được dùng bên trong một biểu thức lớn hơn, ví dụ b = a++.
&& và & khác nhau thế nào khi dùng với boolean?
Cùng là phép VÀ, nhưng && ngắn mạch (vế trái false thì bỏ qua vế phải), còn & luôn tính cả hai vế.
Vì vậy user != null && user.isActive() an toàn, còn user != null & user.isActive() vẫn ném NullPointerException khi user là null. Tương tự với || và |. Với số nguyên, & và | là phép toán bit.
Tính 5 & 3, 5 | 3, 5 ^ 3, 5 << 2, 5 >> 2 và ~5. Vì sao ~5 là số âm?
1, 7, 6, 20, 1, -6; ~5 âm vì đảo cả 32 bit làm bit dấu thành 1.
5 = 0101, 3 = 0011. 5 << 2 là nhân 4, 5 >> 2 là chia 4 làm tròn xuống. Theo bù hai, ~x == -x - 1.
Mid
Integer a = 128, b = 128; a == b cho kết quả gì? Vì sao?
false, vì Integer.valueOf chỉ cache -128 tới 127, còn 128 tạo ra hai object khác nhau.
Autoboxing (tự đóng gói int thành Integer) gọi Integer.valueOf, và == so sánh địa chỉ. Luôn dùng equals (hoặc Objects.equals) để so sánh wrapper.
Switch expression (Java 14+) hơn switch cổ điển ở đâu?
Không lọt case, trả về được giá trị, và compiler kiểm tra đủ trường hợp với enum và sealed type.
Nhiều nhãn gộp được bằng dấu phẩy. Từ Java 21 còn có pattern matching và điều kiện when.
short s = 1; s = s + 1; có biên dịch được không? s += 1 thì sao?
s = s + 1 không biên dịch được; s += 1 thì được.
s + 1 là int và không tự thu hẹp về short. Toán tử gán kép có ép kiểu ngầm về kiểu của vế trái.
Senior
count++ trên biến dùng chung giữa nhiều thread có an toàn không?
Không. Đó là ba bước đọc, cộng, ghi; các thread chen vào giữa nhau làm mất lượt cộng (race condition).
volatile chỉ đảm bảo mọi thread thấy giá trị mới nhất, không làm phép cộng thành atomic. Dùng AtomicInteger.incrementAndGet(), LongAdder (khi nhiều thread cùng ghi), hoặc synchronized.
Một chuỗi if/else hoặc switch theo “loại” cứ dài thêm theo thời gian. Bạn refactor thế nào?
Mục tiêu là thêm loại mới mà không phải sửa code cũ; chọn đa hình, Map<Type, Handler> hoặc sealed interface tuỳ trường hợp.
- Đa hình: mỗi loại là một class cài đặt cùng interface, đúng nguyên tắc Open/Closed.
Map<Type, Handler>hoặc Strategy được Spring inject dưới dạngList<Handler>.- Sealed interface kết hợp switch pattern matching để compiler buộc xử lý đủ trường hợp.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu dùng khi phỏng vấn |
|---|---|---|---|
| two’s complement | /tuːz ˈkɑːmplɪmənt/ | bù hai | “Negative integers are stored in two’s complement.” |
| short-circuit evaluation | /ʃɔːrt ˈsɜːrkɪt/ | đánh giá ngắn mạch | “&& uses short-circuit evaluation, which prevents a null pointer exception.” |
| fall-through | /ˈfɔːl θruː/ | lọt case trong switch | “A missing break causes fall-through in a classic switch.” |
| exhaustive | /ɪɡˈzɔːstɪv/ | đầy đủ mọi trường hợp | “Switch expressions over sealed types must be exhaustive.” |
| guard clause | /ɡɑːrd klɔːz/ | điều kiện thoát sớm | “I prefer guard clauses to deeply nested if statements.” |
| remainder | /rɪˈmeɪndər/ | phần dư (%) |
“In Java the remainder takes the sign of the dividend.” |
| bitwise operator | /ˈbɪtwaɪz/ | toán tử thao tác bit | “Feature flags are often stored as a bitmask and checked with bitwise AND.” |
| compound assignment | /ˈkɑːmpaʊnd/ | toán tử gán kép (+=, *=) |
“Compound assignment includes an implicit narrowing cast.” |
| pattern matching | /ˈpætərn ˈmætʃɪŋ/ | so khớp theo kiểu/cấu trúc | “Pattern matching for switch lets me branch on the type and bind a variable at once.” |
| truth table | /truːθ ˈteɪbl/ | bảng chân trị | “From the truth table, XOR is 1 only when the two bits differ.” |
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.