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
Chọn sai kiểu dữ liệu sinh ra những bug khó thấy nhất: tràn số không báo lỗi, tiền tính bằng double bị lệch, ép kiểu mất dữ liệu âm thầm. Đọc xong, bạn chọn được đúng kiểu, biết primitive và reference nằm đâu trong bộ nhớ, và ép kiểu mà không mất dữ liệu. Nên đọc trước bài về JVM và Hello World; hệ nhị phân và bù hai nằm ở bài tiếp theo, toán tử và rẽ nhánh, cạnh các toán tử bit.
1. Biến và kiểu dữ liệu
Ý chính: biến là một cái tên gắn với một vùng nhớ, giá trị trong đó đổi được khi chương trình chạy. Kiểu dữ liệu quyết định vùng nhớ lớn bao nhiêu và được làm phép toán gì.
Giống phân loại hộp đựng: hộp đựng số nguyên khác hộp đựng chữ.
8 kiểu nguyên thuỷ
Ý chính: 6 kiểu số (4 nguyên, 2 thực), char và boolean. Nhớ phạm vi của int (±2,1 tỷ) và độ chính xác của float/double là đủ cho phần lớn quyết định.
| Kiểu | Kích thước | Phạm vi / độ chính xác | Mặc định (khi là field) |
|---|---|---|---|
byte |
8 bit | -128 … 127 | 0 |
short |
16 bit | -32 768 … 32 767 | 0 |
int |
32 bit | khoảng ±2,1 tỷ (-2³¹ … 2³¹-1) | 0 |
long |
64 bit | khoảng ±9,2 × 10¹⁸ | 0L |
float |
32 bit | khoảng 6–7 chữ số có nghĩa | 0.0f |
double |
64 bit | khoảng 15–16 chữ số có nghĩa | 0.0 |
char |
16 bit | một đơn vị UTF-16, từ '\u0000' tới '\uFFFF' |
'\u0000' |
boolean |
không quy định | true / false |
false |
String không phải kiểu nguyên thuỷ. Nó là class bất biến (immutable — tạo xong không sửa được), nói kỹ ở bài wrapper, BigDecimal và String.
Primitive và reference nằm ở đâu trong bộ nhớ
Ý chính: biến primitive cục bộ chứa luôn giá trị trên stack; biến reference chỉ chứa địa chỉ trỏ tới object trên heap.
Stack là vùng nhớ riêng của từng lời gọi method, tự dọn khi method kết thúc. Heap là vùng nhớ chung chứa object, do GC dọn.
flowchart LR
subgraph Stack["Stack (frame của main)"]
a["int age = 30"]
s["String name = ref"]
end
subgraph Heap
o["String object 'Vinh'"]
end
s --> o
Nắm hình này thì hiểu vì sao truyền mảng vào hàm thì bị sửa, còn truyền int thì không (xem bài vòng lặp và hàm).
Vì sao Java tách primitive và reference
Ý chính: vì hiệu năng. Một int là 4 byte nằm ngay trong biến, còn một object cần thêm header, một tham chiếu và một lần đọc bộ nhớ nữa.
- Kiểu tham chiếu gồm
String,Object, mảng (int[]cũng là object), collection (List,Map,Set) và mọi class bạn tự viết. - Giá của object: header khoảng 12–16 byte (thông tin JVM gắn vào mỗi object), cộng tham chiếu trỏ tới nó.
- Giá của primitive: không có method, không nhận
null, không dùng trực tiếp với generics.
Wrapper class, boxing và unboxing
Ý chính: mỗi primitive có một class “bọc” để dùng ở nơi chỉ nhận object. Compiler tự đổi qua lại (autoboxing / unboxing).
Các cặp: byte → Byte, short → Short, int → Integer, long → Long, float → Float, double → Double, char → Character, boolean → Boolean. Cần wrapper vì:
- collection chỉ chứa object (
List<Integer>, không cóList<int>); - cần
nullđể nói “không có giá trị” (cột nullable trong database); - wrapper có sẵn hàm tiện ích.
Integer boxed = 42; // autoboxing: compiler viết thành Integer.valueOf(42)
int unboxed = boxed; // unboxing: compiler viết thành boxed.intValue()
int parsed = Integer.parseInt("123"); // String -> int, chuỗi sai định dạng ném NumberFormatException
Integer.MAX_VALUE; // 2147483647
Character.isDigit('7'); // true
Boolean.parseBoolean("yes"); // false: chỉ "true" (không phân biệt hoa thường) mới là true
Khai báo, khởi tạo, var, final
Ý chính: khai báo là xin vùng nhớ, khởi tạo là đặt giá trị vào. var để compiler tự suy ra kiểu, final chỉ cho gán một lần.
int quantity; // khai báo: xin một vùng nhớ cho int
quantity = 3; // khởi tạo/gán: đặt giá trị vào vùng nhớ đó
double price = 19.99; // khai báo và gán cùng lúc
var total = price * quantity; // Java 10+: compiler tự suy ra kiểu double
final int MAX_ITEMS = 100; // gán đúng một lần
long population = 8_100_000_000L; // phải có hậu tố L, nếu không sẽ lỗi vì vượt int
float ratio = 0.75f; // literal 0.75 mặc định là double, muốn float thì thêm f
Như cái cốc: khai báo là lấy cốc rỗng đúng loại, khởi tạo là rót nước vào. Rót thứ không hợp (gán "abc" vào int) thì compiler báo lỗi ngay.
Đặt tên
Ý chính: có hai tầng. Quy tắc bắt buộc (sai thì không biên dịch) và quy ước (sai vẫn chạy, nhưng Checkstyle hay Sonar sẽ bắt).
Quy ước của Java:
| Loại | Quy ước | Ví dụ |
|---|---|---|
| Biến, method | camelCase |
orderTotal, findById() |
| Class, interface, record, enum | PascalCase |
OrderService |
Hằng số (static final) |
UPPER_SNAKE_CASE |
MAX_RETRY |
| Package | chữ thường, tên miền ngược | com.vinhnq.billing |
Slide nêu snake_case như một cách đặt tên biến. Nó hợp lệ về cú pháp nhưng không phải quy ước của Java. Gặp snake_case trong code Java thường là tên cột database hoặc field JSON.
Quy tắc bắt buộc:
- Chỉ gồm chữ cái, chữ số,
_và$.điểmcũng hợp lệ (chữ Unicode) nhưng đừng dùng. - Không bắt đầu bằng chữ số.
- Không trùng từ khoá (
if,class,new,int…) hay literaltrue,false,null. Từ Java 9, một mình_cũng là từ khoá. - Phân biệt hoa thường:
totalvàTotallà hai biến khác nhau.
Thử đoán: abc, 1abc, ab_c, _abc, $abc, ab-c, _123, $123, if, $if. Chỉ 1abc (bắt đầu bằng số), ab-c (- là toán tử trừ) và if (từ khoá) là sai; $if hợp lệ vì không còn là từ khoá. Hợp lệ chưa chắc nên dùng: $ dành cho code do công cụ sinh ra, _123 chẳng nói lên điều gì.
Ép kiểu (casting)
Ý chính: từ kiểu hẹp sang rộng thì tự động (widening); từ rộng sang hẹp phải viết (kiểu) (narrowing) và có thể mất dữ liệu mà không cảnh báo.
flowchart LR
byte --> short --> int --> long --> float --> double
char --> int
- Ngầm định (widening — mở rộng): đi theo mũi tên, compiler tự làm. Riêng
int → floatvàlong → floattuy tự động nhưng có thể mất độ chính xác, vìfloatchỉ có khoảng 24 bit phần định trị. - Tường minh (narrowing — thu hẹp): đi ngược mũi tên, phải viết
(kiểu). Mất dữ liệu không có cảnh báo nào.
long big = 123_456_789_123L;
float f = big; // tự động, nhưng giá trị thành 1.23456790528E11 (đã lệch)
double d = 3.99;
int truncated = (int) d; // 3: phần lẻ bị cắt, không làm tròn
int negative = (int) -3.99; // -3: cắt về phía 0
long rounded = Math.round(d); // 4
int tooBig = 200;
byte b = (byte) tooBig; // -56: chỉ giữ 8 bit thấp, giá trị bị quấn vòng
char letter = 'A';
int code = letter; // 65: char tự động lên int
char next = (char) (code + 1); // 'B'
int safe = Math.toIntExact(5_000_000_000L); // ném ArithmeticException thay vì âm thầm cắt
Ký tự cũng là số: ASCII, Unicode và các hệ cơ số
Ý chính: máy chỉ lưu số, nên mỗi ký tự có một mã số. Trong Java char là số nguyên không dấu 16 bit, nên cộng trừ được như số.
ASCII là bảng mã 7 bit (mã 0–127) từ những năm 1960: chữ cái tiếng Anh, chữ số, dấu câu, ký tự điều khiển. Vài mốc nên nhớ:
| Ký tự | Mã (hệ 10) | Hệ 16 | Ghi chú |
|---|---|---|---|
'\n' |
10 | 0x0A |
xuống dòng (LF) |
' ' |
32 | 0x20 |
dấu cách |
'0' … '9' |
48 … 57 | 0x30 … 0x39 |
ký tự '0' khác số 0 |
'A' … 'Z' |
65 … 90 | 0x41 … 0x5A |
|
'a' … 'z' |
97 … 122 | 0x61 … 0x7A |
chữ thường = chữ hoa + 32 |
int code = 'e'; // 101
char letter = (char) 65; // 'A'
int digit = '7' - '0'; // 7: đổi ký tự chữ số thành giá trị
int gap = 'a' - 'A'; // 32
char upper = (char) ('g' - 32); // 'G' (code thật thì dùng Character.toUpperCase)
char c = 'A';
c += 1; // 'B': phép gán kép tự ép về char
// c = c + 1; // lỗi biên dịch: c + 1 có kiểu int
System.out.println('A' + 'B'); // 131: cộng hai char ra int
System.out.println("" + 'A' + 'B'); // AB
Slide nói “ép char sang int để lấy mã ASCII”. Câu đó chỉ đúng với 128 ký tự đầu: (int) 'Đ' ra 272, không có trong bảng ASCII.
Unicode, UTF-16, UTF-8 và literal ở bốn hệ cơ số
ASCII chỉ là 128 mã đầu của Unicode. Unicode gán mã (code point, viết dạng U+0110 cho chữ Đ) cho hơn 150 000 ký tự của mọi hệ chữ viết.
- Java lưu chuỗi theo UTF-16: một
charlà một đơn vị mã UTF-16, chứa được ký tự từU+0000tớiU+FFFF. Ký tự ngoài khoảng đó, như emoji, cần haichar. - Khi ghi file hay gửi qua mạng, chuỗi được mã hoá thành byte, thường là UTF-8. Trong UTF-8 ký tự ASCII vẫn chiếm đúng 1 byte, và đó là lý do UTF-8 thành chuẩn chung.
Bảng ASCII thường in kèm cột hệ 8 (octal) và hệ 16 (hex). Java viết được literal số nguyên ở cả bốn hệ:
int dec = 65;
int hex = 0x41; // tiền tố 0x: hệ 16
int oct = 0101; // bắt đầu bằng số 0: hệ 8
int bin = 0b1000001; // tiền tố 0b: hệ 2 (Java 7+)
// cả bốn đều bằng 65, tức là bằng 'A'
Integer.toHexString(65); // "41"
Integer.toOctalString(65); // "101"
Integer.toBinaryString(65); // "1000001"
Hex gặp nhiều nhất trong công việc, vì một chữ số hex ứng với đúng 4 bit: màu 0xFF8800, mã lỗi, địa chỉ bộ nhớ trong log, giá trị hash, escape \u0041 trong chuỗi.
Bài tập
Đề 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 2: biến và kiểu dữ liệu
- 2.1. Giải phương trình bậc nhất
ax + b = 0. Nhớ xéta = 0, chỗ hay bị quên. - 2.2. Đổi inch sang cm (1 inch = 2,54 cm).
- 2.3. Đổi độ C ↔ F. Input là đơn vị hiện tại kèm giá trị:
C 40ra104,F 10ra-12.2. - 2.4. Đổi số phút sang năm, ngày, giờ, phút (một năm = 365 ngày). 71 phút ra
0 năm, 0 ngày, 1 giờ, 11 phút. - 2.5. Tính giai thừa n!.
Lời giải 2.1–2.5
2.1.
static String solveLinear(double a, double b) {
if (a == 0) return b == 0 ? "Vô số nghiệm" : "Vô nghiệm";
return "x = " + (-b / a);
}
2.2. return inch * 2.54;.
2.3.
static double convertTemperature(char unit, double value) {
return switch (Character.toUpperCase(unit)) {
case 'C' -> value * 9 / 5 + 32;
case 'F' -> (value - 32) * 5 / 9;
default -> throw new IllegalArgumentException("Đơn vị phải là C hoặc F: " + unit);
};
}
2.4.
static String formatMinutes(long totalMinutes) {
long perDay = 24 * 60, perYear = 365 * perDay;
long years = totalMinutes / perYear;
long days = totalMinutes % perYear / perDay;
long hours = totalMinutes % perDay / 60;
long minutes = totalMinutes % 60;
return "%d năm, %d ngày, %d giờ, %d phút".formatted(years, days, hours, minutes);
}
Mẫu chung: / lấy phần nguyên của đơn vị lớn, % lấy phần còn lại. Code thực tế thì dùng java.time.Duration.ofMinutes(n), có sẵn toDaysPart(), toHoursPart().
2.5.
static long factorial(int n) {
if (n < 0 || n > 20) throw new IllegalArgumentException("n phải trong [0, 20]");
long result = 1;
for (int i = 2; i <= n; i++) result *= i;
return result;
}
21! đã vượt long. Cần số lớn hơn thì dùng BigInteger.
- 2.7. Đổi số nguyên dương nhỏ hơn 1000 sang số La Mã.
- 2.8. Ba số có phải ba cạnh tam giác không; nếu có thì là loại gì, chu vi và diện tích bao nhiêu.
- 2.9. Kiểm tra số hoàn hảo: số bằng tổng các ước thực sự của nó, ví dụ 6 = 1 + 2 + 3.
- 2.10. Giải phương trình bậc hai
ax² + bx + c = 0. - 2.11. Rút tiền với ít tờ nhất từ các mệnh giá 500, 200, 100, 20, 10, 5, 2, 1.
Lời giải 2.7–2.11
2.7. Tham lam trên bảng giá trị có sẵn cả các cặp trừ như 900 (CM) và 4 (IV):
static String toRoman(int n) {
if (n <= 0 || n >= 1000) throw new IllegalArgumentException("n phải trong [1, 999]");
int[] values = {900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
String[] symbols = {"CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
StringBuilder sb = new StringBuilder();
for (int i = 0; i < values.length; i++) {
while (n >= values[i]) { sb.append(symbols[i]); n -= values[i]; }
}
return sb.toString(); // 944 -> CMXLIV
}
2.8. Diện tích theo công thức Heron. So sánh số thực bằng sai số eps, không dùng ==.
static String describeTriangle(double a, double b, double c) {
if (a <= 0 || b <= 0 || c <= 0 || a + b <= c || a + c <= b || b + c <= a) return "Không phải tam giác";
final double eps = 1e-9;
double[] s = {a, b, c};
java.util.Arrays.sort(s);
boolean right = Math.abs(s[0] * s[0] + s[1] * s[1] - s[2] * s[2]) < eps;
boolean equilateral = Math.abs(a - b) < eps && Math.abs(b - c) < eps;
boolean isosceles = Math.abs(a - b) < eps || Math.abs(b - c) < eps || Math.abs(a - c) < eps;
String kind = equilateral ? "đều" : isosceles ? (right ? "vuông cân" : "cân") : (right ? "vuông" : "thường");
double p = (a + b + c) / 2;
double area = Math.sqrt(p * (p - a) * (p - b) * (p - c));
return "%s, chu vi=%.2f, diện tích=%.2f".formatted(kind, a + b + c, area);
}
2.9. Chỉ duyệt tới √n, mỗi lần tìm được ước d thì cộng luôn cả n/d:
static boolean isPerfect(long n) {
if (n < 2) return false;
long sum = 1;
for (long d = 2; d * d <= n; d++) {
if (n % d == 0) {
sum += d;
if (d != n / d) sum += n / d;
}
}
return sum == n; // 6, 28, 496, 8128
}
O(√n) thay vì O(n). Với n cỡ 10¹², đó là 10⁶ so với 10¹² phép tính.
2.10.
static String solveQuadratic(double a, double b, double c) {
if (a == 0) return solveLinear(b, c); // suy biến về bậc nhất
double delta = b * b - 4 * a * c;
if (delta < 0) return "Vô nghiệm thực";
if (delta == 0) return "Nghiệm kép x = " + (-b / (2 * a));
double sqrt = Math.sqrt(delta);
return "x1 = " + (-b + sqrt) / (2 * a) + ", x2 = " + (-b - sqrt) / (2 * a);
}
2.11.
static java.util.Map<Integer, Integer> withdraw(int amount) {
int[] notes = {500, 200, 100, 20, 10, 5, 2, 1};
var result = new java.util.LinkedHashMap<Integer, Integer>();
for (int note : notes) {
if (amount >= note) { result.put(note, amount / note); amount %= note; }
}
return result; // 1288 -> {500=2, 200=1, 20=4, 5=1, 2=1, 1=1}, tổng 10 tờ
}
- 2.12. Lên đơn hàng (chỉ có trong bản slide thứ hai): nhập tên, giá, số lượng của 3 sản phẩm, tính giá trung bình và tổng tiền đơn hàng. Điểm chính: tiền dùng
BigDecimal, và mọi giá trị đọc bằngnextLine()rồi tự parse để tránh lỗi trộnnextIntvớinextLine(giải thích ở bài nhập xuất console và file).
Lời giải 2.12
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Scanner;
public class OrderDemo {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
BigDecimal sumPrice = BigDecimal.ZERO, total = BigDecimal.ZERO;
for (int i = 1; i <= 3; i++) {
System.out.print("Tên SP " + i + ": ");
String name = in.nextLine();
System.out.print("Giá: ");
BigDecimal price = new BigDecimal(in.nextLine().trim());
System.out.print("Số lượng: ");
int qty = Integer.parseInt(in.nextLine().trim());
sumPrice = sumPrice.add(price);
total = total.add(price.multiply(BigDecimal.valueOf(qty)));
System.out.println("Đã thêm " + name);
}
System.out.println("Giá trung bình: " + sumPrice.divide(BigDecimal.valueOf(3), 2, RoundingMode.HALF_UP));
System.out.println("Tổng đơn: " + total);
}
}
Lab 01: nhập từ bàn phím và in kết quả
Đề (viết lại): (1) nhập tên và điểm trung bình của một sinh viên, in ra dạng "Eric" có điểm = 9.6; (2) nhập hai cạnh hình chữ nhật, in chu vi, diện tích và cạnh ngắn hơn; (3) nhập cạnh khối lập phương, in thể tích.
Lời giải Lab 01 và nhận xét
import java.util.Locale;
import java.util.Scanner;
public class Lab01 {
// Đọc cả dòng rồi tự parse: tránh bẫy nextDouble() + nextLine(), chấp nhận cả "9,6" và "9.6"
static double readNumber(Scanner in, String prompt, double min, double max) {
while (true) {
System.out.print(prompt);
String raw = in.nextLine().trim().replace(',', '.');
try {
double value = Double.parseDouble(raw);
if (value >= min && value <= max) return value;
} catch (NumberFormatException ignored) {
// rơi xuống dòng báo lỗi bên dưới
}
System.out.printf("Cần một số trong [%s, %s], bạn nhập \"%s\"%n", min, max, raw);
}
}
static double perimeter(double length, double width) { return 2 * (length + width); }
static double area(double length, double width) { return length * width; }
static double cubeVolume(double edge) { return edge * edge * edge; }
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
double minSide = 0.001, maxSide = 1_000_000; // cạnh phải dương; chặn trên để loại dữ liệu vô lý
// Bài 1: tên và điểm trung bình
System.out.print("Tên sinh viên: ");
String name = in.nextLine().strip();
double score = readNumber(in, "Điểm trung bình: ", 0, 10);
System.out.printf(Locale.ROOT, "\"%s\" có điểm = %.1f%n", name, score);
// Bài 2: hình chữ nhật
double length = readNumber(in, "Cạnh thứ nhất: ", minSide, maxSide);
double width = readNumber(in, "Cạnh thứ hai: ", minSide, maxSide);
System.out.printf(Locale.ROOT, "Chu vi: %.2f%nDiện tích: %.2f%nCạnh nhỏ nhất: %.2f%n",
perimeter(length, width), area(length, width), Math.min(length, width));
// Bài 3: khối lập phương
double edge = readNumber(in, "Cạnh khối lập phương: ", minSide, maxSide);
System.out.printf(Locale.ROOT, "Thể tích: %.2f%n", cubeVolume(edge));
}
}
Input Eric, 9,6, abc, 4, -2, 2.5, 3 cho ra "Eric" có điểm = 9.6, hỏi lại khi gặp abc và -2, rồi in 13.00, 10.00, 2.50, 27.00.
- Đề gợi ý
Math.pow(canh, 3). Đúng, nhưngpowlà hàm tổng quát cho số mũ thực, chậm hơn và luôn trảdouble. Với số mũ nguyên nhỏ,edge * edge * edgerõ và chính xác hơn. Locale.ROOTgiữ dấu chấm thập phân. Không có nó, máy đặt locale tiếng Việt sẽ in9,6.- Senior sẽ làm thêm: tách phần tính toán (thuần, không I/O) ra để viết unit test; dùng
BigDecimalnếu điểm cần làm tròn theo quy chế; luôn kiểm tra khoảng giá trị của input người dùng thay vì tin họ nhập đúng.
Ghi nhớ
- Kể được 8 kiểu nguyên thuỷ và giải thích vì sao
Stringkhông nằm trong đó. - Vẽ được stack và heap cho một biến
intvà một biếnString. - Giải thích được vì sao
int q = map.get("x")có thể némNullPointerException. - Biết khi nào ép kiểu mất dữ liệu (
(byte) 200,(int) 3.99,long → float) và cách chặn bằngMath.toIntExact. - Biết vì sao tiền không dùng
doublevà nên dùng gì thay.
Câu hỏi phỏng vấn
Junior
Java có 8 kiểu nguyên thuỷ nào? String có phải kiểu nguyên thuỷ không?
byte, short, int, long, float, double, char, boolean. String không phải: nó là class (kiểu tham chiếu) và bất biến.
Compiler chỉ hỗ trợ riêng cho String literal "..." và toán tử +.
Tên nào hợp lệ: 1abc, _123, $if, ab-c, if?
Hợp lệ: _123 và $if. Không hợp lệ: 1abc (bắt đầu bằng chữ số), ab-c (- là toán tử), if (từ khoá).
Quy tắc: chỉ gồm chữ cái, chữ số, _, $; không bắt đầu bằng số; không trùng từ khoá hay true/false/null; _ đứng một mình là từ khoá từ Java 9. Hợp lệ khác với đúng quy ước: biến dùng camelCase, hằng số dùng UPPER_SNAKE_CASE.
Wrapper class dùng để làm gì? Autoboxing là gì?
Wrapper bọc primitive thành object để dùng với collection và generics, biểu diễn null, và có hàm tiện ích. Autoboxing là compiler tự đổi int thành Integer.
Autoboxing gọi Integer.valueOf; unboxing là chiều ngược lại, gọi intValue(). Bẫy: unboxing null ném NullPointerException, và so sánh hai wrapper bằng == là so sánh địa chỉ.
Biến cục bộ có giá trị mặc định không?
Không. Chỉ field của object và phần tử mảng mới có giá trị mặc định (0, false, null…).
Đọc biến cục bộ chưa gán thì không biên dịch được (“variable might not have been initialized”). Đó là cách compiler chặn lỗi dùng giá trị rác như trong C.
'a' + 1 có kiểu gì? Vì sao c = c + 1 với char c bị lỗi còn c += 1 thì không?
'a' + 1 là int (98), vì char được nâng lên int trước khi tính. c += 1 ngầm chứa phép ép về char, còn c = c + 1 thì không.
byte và short cũng được nâng lên int như vậy. Gán int vào char là ép kiểu thu hẹp, phải viết c = (char) (c + 1). Cùng lý do, 'A' + 'B' in ra 131 chứ không phải AB.
Mid
Ép kiểu ngầm định và tường minh khác nhau thế nào? Cho ví dụ mất dữ liệu.
Ngầm định đi từ kiểu hẹp sang rộng, compiler tự làm. Tường minh đi từ rộng sang hẹp, phải viết (type) và có thể mất dữ liệu.
Ví dụ: (byte) 200 == -56 (chỉ giữ 8 bit thấp), (int) 3.99 == 3 (cắt phần lẻ). Ngay cả chuyển ngầm long → float cũng có thể mất độ chính xác.
Vì sao 0.1 + 0.2 != 0.3? Tính tiền thì làm thế nào?
Vì double lưu dạng nhị phân (IEEE 754) và 0,1 không biểu diễn chính xác được ở hệ 2. Tiền dùng BigDecimal hoặc long theo đơn vị nhỏ nhất.
BigDecimal nên tạo từ String và chỉ rõ RoundingMode. Nếu dùng long thì lưu theo cent hoặc đồng.
var có làm Java thành ngôn ngữ kiểu động không?
Không. var chỉ là suy luận kiểu lúc biên dịch cho biến cục bộ; kiểu vẫn cố định.
var list = new ArrayList<String>() có kiểu ArrayList<String>, gán list = 5 sau đó là lỗi biên dịch. var không dùng được cho field, tham số method hay kiểu trả về, và phải có giá trị khởi tạo (không viết var x; hay var x = null;).
Biến primitive và object nằm ở đâu trong bộ nhớ?
Biến cục bộ (primitive lẫn tham chiếu) nằm trong stack frame của method. Object, kể cả mảng, nằm trên heap.
Biến tham chiếu chỉ chứa địa chỉ của object. Primitive là field của object thì nằm trong object đó, tức là trên heap. Thêm: JIT có escape analysis (phân tích xem object có “thoát” khỏi method không), nên object không thoát có thể được tách thành các biến vô hướng và không cần cấp phát trên heap.
Senior
Tràn số nguyên có ném exception không? Phòng tránh thế nào trong code production?
Không. Số lưu theo bù hai nên tràn là quay vòng âm thầm: Integer.MAX_VALUE + 1 == Integer.MIN_VALUE.
Cách phòng:
Math.addExact,multiplyExact,toIntExactnémArithmeticExceptionkhi tràn.- Dùng
longcho tiền, bộ đếm, timestamp;BigIntegerkhi không biết trước giới hạn. - Bug kinh điển: trung điểm
(lo + hi) / 2trong binary search bị tràn. Viếtlo + (hi - lo) / 2hoặc(lo + hi) >>> 1.
Vì sao không có List<int>? Boxing tốn kém thế nào với dữ liệu lớn?
Generics bị xoá kiểu (type erasure) về Object, mà primitive không phải Object. Với dữ liệu lớn, boxing tốn gấp 4–5 lần bộ nhớ so với mảng primitive.
Một List<Integer> một triệu phần tử gồm mảng tham chiếu (4–8 byte mỗi ô) cộng một triệu object Integer (khoảng 16 byte mỗi cái) rải rác trên heap. int[] chỉ là 4 MB liền nhau. Hệ quả: tốn bộ nhớ, nhiều cache miss, tăng áp lực lên GC.
Dữ liệu số lớn thì dùng mảng primitive, IntStream, hoặc thư viện collection cho primitive (fastutil, Eclipse Collections). Project Valhalla đang hướng tới cho phép generics trên kiểu giá trị.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu dùng khi phỏng vấn |
|---|---|---|---|
| primitive type | /ˈprɪmətɪv/ | kiểu nguyên thuỷ | “Java has eight primitive types, and String is not one of them.” |
| reference type | /ˈrefərəns/ | kiểu tham chiếu | “A reference type variable holds a pointer to an object on the heap.” |
| widening / narrowing conversion | /ˈwaɪdnɪŋ/ /ˈnæroʊɪŋ/ | ép kiểu mở rộng / thu hẹp | “Narrowing conversions require an explicit cast and may lose data.” |
| overflow | /ˈoʊvərfloʊ/ | tràn số | “Integer overflow wraps around silently, so I use Math.addExact.” |
| precision | /prɪˈsɪʒn/ | độ chính xác | “Floating-point types lose precision, so money should use BigDecimal.” |
| type inference | /ˈɪnfərəns/ | suy luận kiểu | “var relies on local type inference; it is still statically typed.” |
| autoboxing | /ˈɔːtoʊbɑːksɪŋ/ | tự động đóng gói primitive thành wrapper | “Autoboxing can hide a NullPointerException when a wrapper is null.” |
| identifier | /aɪˈdentɪfaɪər/ | định danh (tên biến, class…) | “An identifier can’t start with a digit or be a reserved keyword.” |
| wrapper class | /ˈræpər/ | lớp bọc của kiểu nguyên thuỷ | “Collections only hold objects, so ints are boxed into the Integer wrapper class.” |
| code point | /koʊd pɔɪnt/ | mã số Unicode của một ký tự | “An emoji is one code point but two chars in Java.” |
| character encoding | /ˈkærəktər ɪnˈkoʊdɪŋ/ | bảng mã, cách đổi ký tự thành byte | “Always pass the character encoding explicitly, usually UTF-8.” |
| significant digits | /sɪɡˈnɪfɪkənt/ | chữ số có nghĩa | “A float keeps about seven significant digits, not seven decimal places.” |
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.