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 8 phútMã đã được kiểm chứng

Các kiểu nguyên thủy của Java, và bốn kiểu khiến ai cũng vấp

Tám kiểu, khoảng hai mươi phút học thuộc — và bốn hành vi sẽ làm bạn mất điểm cho đến khi có người chỉ ra. Mọi kết quả trên trang này đều đã được thực thi, không phải nhớ lại.

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 cây thước không có phần ba#

Lấy một cây thước chỉ có vạch nửa, rồi một phần tư, rồi một phần tám, rồi một phần mười sáu, và cứ tiếp tục mịn đến mức bạn muốn.

Bạn đo được chính xác một nửa. Một phần tư, chính xác. Ba phần tám, chính xác. Giờ hãy đo một phần ba. Bạn không thể. Không phải vì thước của bạn rẻ tiền, cũng không phải vì bạn đo cẩu thả — một phần ba đơn giản không phải là một trong các vạch, và sẽ không bao giờ, dù bạn chia mịn đến đâu. Điều tốt nhất bạn làm được là rơi vào vạch gần nhất và lệch đi một chút.

Máy tính lưu số thập phân đúng trên cây thước đó. Các vạch của nó là nửa, một phần tư và một phần tám, vì nó đếm theo hai. Bất cứ thứ gì không được tạo từ những mảnh đó sẽ nhận vạch gần nhất, và 0.1 là một trong những số trượt.

Mỗi kiểu trên trang này đều có một ranh giới như vậy: một điểm mà ở đó nó ngừng hành xử như trục số trong đầu bạn. Những ranh giới đó là thứ bài thi hỏi, nên chúng ta sẽ đi qua cả tám kiểu và đánh dấu nơi mỗi kiểu bị vỡ.

Dòng này có in ra true không?#

System.out.println(0.1 + 0.2 == 0.3);

Đúng hay sai? Hãy quyết định trước khi cuộn xuống.

Hầu như ai cũng nói true. Ở đây chẳng có gì trông khó — đó là phép tính chúng ta học từ năm tám tuổi.

false

Không phải lỗi, và cũng không phải Java làm khó. double lưu số ở dạng nhị phân, và 0.1 không có dạng nhị phân chính xác, y như 1/3 không có dạng thập phân chính xác. Vì vậy 0.1 + 0.2 rơi xuống cao hơn 0.3 một chút, và == so sánh trung thực rồi nói không.

Mỗi kiểu nguyên thủy đều có một hình dạng như vậy: một kích thước, một khoảng giá trị, và một ranh giới mà ở đó nó ngừng hành xử như trục số. Những ranh giới đó là thứ được hỏi trong bài thi, nên chúng ta sẽ đi qua cả tám kiểu và đánh dấu nơi mỗi kiểu bị vỡ.

Thay vào đó nên làm gì

Đừng bao giờ so sánh các double bằng ==. Hãy kiểm tra chúng đủ gần nhau: Math.abs(a - b) < 1e-9. Với tiền, đừng dùng double chút nào — hãy dùng BigDecimal hoặc đếm số xu nguyên trong một int.

Tám kiểu nguyên thủy#

Java có đúng tám kiểu nguyên thủy. Chúng không phải đối tượng, chúng giữ giá trị trực tiếp, và chúng là các kiểu duy nhất hoạt động theo cách này — mọi thứ khác trong Java, kể cả String, là kiểu tham chiếu.

KiểuKích thướcKhoảng giá trịCách viết giá trị (literal)
byte8 bit−128 đến 127(byte) 100
short16 bit−32768 đến 32767(short) 1000
int32 bit−2147483648 đến 214748364742
long64 bit−9223372036854775808 đến 922337203685477580742L
float32 bitđộ chính xác khoảng 7 chữ số thập phân3.14f
double64 bitđộ chính xác khoảng 15 chữ số thập phân3.14
char16 bit0 đến 65535 (một mã ký tự)'A'
boolean—chỉ true hoặc falsetrue

Hai trong số các hàng đó đáng xem lại. int là mặc định cho số nguyên và double là mặc định cho số thập phân — chính là lý do hai lỗi tiếp theo xảy ra.

Literal có kiểu trước khi được gán#

Dòng này trông như hiển nhiên phải chạy được, và nó không biên dịch được:

long big = 10000000000;
Big.java:3: error: integer number too large
        long big = 10000000000;
                   ^
1 error

Biến là một long, vậy cái gì quá lớn? Chính literal. Java đọc 10000000000 như một int trước khi nó nhìn đến vế trái, và mười tỷ không vừa trong một int. Hậu tố L bảo trình biên dịch đọc nó như một long ngay từ đầu:

long big = 10000000000L;   // compiles

Hãy đọc to là “mười tỷ, long”. L không phải đồ trang trí và không phải một phần của con số; đó là chỉ dẫn cho trình biên dịch về việc đọc các chữ số như kiểu nào, được đưa ra trước khi nó đọc chúng.

Điều tương tự xảy ra với float, theo chiều ngược lại:

float f = 3.14;
Flt.java:3: error: incompatible types: possible lossy conversion from double to float
        float f = 3.14;
                  ^
1 error

3.14 là một double, và nhét một giá trị 64 bit vào một biến 32 bit có thể làm mất độ chính xác, nên Java từ chối. Hãy viết 3.14f.

Mẫu chung đằng sau cả hai

Java sẽ âm thầm mở rộng một giá trị sang kiểu lớn hơn, nhưng không bao giờ âm thầm thu hẹp nó sang kiểu nhỏ hơn. Việc thu hẹp cần sự cho phép rõ ràng của bạn, dưới dạng một hậu tố hoặc một phép ép kiểu. Ngay cả dòng này cũng lỗi, vì giá trị của một biến không được biết lúc biên dịch:

int x = 5;
byte b = x;   // error: incompatible types: possible lossy conversion from int to byte

Bẫy 1 — chia số nguyên bỏ phần dư#

Nếu cả hai toán hạng đều là số nguyên, Java thực hiện phép chia số nguyên. Không có làm tròn nào ở đây:

System.out.println(7 / 2);
System.out.println(7 % 2);
System.out.println(7.0 / 2);
3
1
3.5

7 / 2 là 3, không phải 3.5 và không phải 4. Toán tử % lấy lại phần dư mà phép chia đã bỏ đi.

Cách sửa là làm cho ít nhất một toán hạng là dấu phẩy động — nhưng bạn đặt phép ép kiểu ở đâu quyết định nó có chạy hay không:

System.out.println((double) 7 / 2);     // cast first, then divide
System.out.println((double) (7 / 2));   // divide first, then cast
3.5
3.0

Ở dòng thứ hai, thiệt hại đã xảy ra: 7 / 2 đã được tính thành int 3, và ép 3 sang double cho 3.0. Phép ép kiểu không thể lấy lại thông tin đã bị bỏ đi.

Bẫy 2 — tràn số xảy ra âm thầm#

System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MAX_VALUE + 1);
2147483647
-2147483648

Cộng một vào int lớn nhất có thể cho ra int nhỏ nhất có thể. Không ngoại lệ, không cảnh báo, không sập — giá trị quay vòng như đồng hồ đo quãng đường của xe hơi lật số, và chương trình tiếp tục với một con số sai.

Đó là lý do các bộ đếm, tổng cộng dồn, và bất cứ thứ gì đo bằng mili giây thường muốn dùng long, không phải int.

Bẫy 3 — số thập phân không chính xác#

System.out.println(0.1 + 0.2);
System.out.println(0.1 + 0.2 == 0.3);
0.30000000000000004
false

double và float lưu giá trị ở dạng nhị phân. Một phần mười không thể được viết chính xác ở dạng nhị phân vì cùng lý do một phần ba không thể được viết chính xác ở dạng thập phân — các chữ số không bao giờ dừng. Thứ được lưu là giá trị gần nhất có sẵn, và những sai số nhỏ tích lũy lại.

Hệ quả

đừng bao giờ so sánh các giá trị dấu phẩy động bằng ==. Hãy so sánh độ lớn của hiệu với một ngưỡng sai số nhỏ: Math.abs(a - b) < 1e-9. Và đừng bao giờ dùng double cho tiền — hãy đếm số xu nguyên trong một int hoặc long.

Bẫy 4 — char là một con số mặc áo hóa trang#

System.out.println('A' + 1);
System.out.println((char) ('A' + 1));
66
B

Một char giữ một số xác định một ký tự; 'A' là 65. Vì vậy phép tính trên nó cho ra một số, và Java nâng kết quả lên int — đó là lý do dòng đầu in ra 66 chứ không phải 'B'. Ép kết quả về char cho ra chữ cái.

Điều này thật sự hữu ích khi bạn đã biết trước. ch - 'a' đổi một chữ cái thường sang vị trí của nó trong bảng chữ cái, và (char) ('a' + n) đổi một vị trí về lại chữ cái.

Ép kiểu cắt bỏ, không làm tròn#

System.out.println((int) 9.99);
System.out.println((int) -9.99);
9
-9

Ép kiểu sang int xóa phần thập phân và di chuyển về phía 0. Nó cũng không phải Math.floor — floor sẽ cho −10 ở cái thứ hai. Nếu bạn muốn làm tròn, hãy nói rõ bằng Math.round.

Những chỗ dễ sai#

  • Tính trung bình bằng phép chia số nguyên. (a + b) / 2 trên hai int âm thầm cắt bỏ. Đây là dạng phổ biến nhất của Bẫy 1.
  • Ép kiểu sau khi đã muộn. (double) (sum / count) là quá muộn. Hãy ép kiểu một toán hạng, không phải kết quả.
  • Dùng == trên các double. Nó biên dịch, nó chạy, và nó trả về false cho những giá trị trông giống hệt nhau khi in ra.
  • Quên L và f. Cả hai đều gây ra lỗi biên dịch nêu tên một kiểu mà bạn không viết, khiến chúng gây rối cho đến khi bạn biết rằng literal có kiểu riêng của nó.
  • Mong tràn số tự báo hiệu. Nó không. Một tổng đột nhiên trở thành số âm là triệu chứng.
  • Đọc 'A' + 1 như phép nối chuỗi. Nối chuỗi nghĩa là nối văn bản đầu nối đuôi, và nó cần một String ở một bên của +. Cả hai toán hạng ở đây đều là số, nên + là phép cộng thông thường.
Một câu để mang vào phòng thi

Mỗi kiểu nguyên thủy đều có một ranh giới mà ở đó nó ngừng hành xử như trục số. Phép chia số nguyên bỏ phần dư, tràn số xảy ra trong im lặng, số thập phân chỉ là xấp xỉ, và một phép ép kiểu cắt bỏ chứ không làm tròn. Bốn ranh giới, và chúng là thứ được hỏi trong bài thi.

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

Luyện tập theo chủ đề: dùng được khi không có mạng, không quảng cáo, không cần tài khoản.

Luyện tập chủ đề này →

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

Vì sao 7 / 2 cho kết quả 3 trong Java?

Vì cả hai toán hạng đều là int, nên Java thực hiện phép chia số nguyên và bỏ phần dư. Đó không phải làm tròn — 7 / 2 là 3, không phải 4. Để có 3.5, ít nhất một vế phải là giá trị dấu phẩy động: dùng 7.0 / 2, hoặc ép kiểu một toán hạng bằng (double) 7 / 2.

Tám kiểu nguyên thủy trong Java là gì?

byte, short, int, long, float, double, char và boolean. Mọi thứ khác trong Java — kể cả String — là kiểu tham chiếu, không phải kiểu nguyên thủy.

Vì sao tôi không thể viết long big = 10000000000;?

Vì chính literal được coi là một int trước khi nó được gán, và nó không vừa trong một int. Trình biên dịch báo “integer number too large”. Hãy thêm hậu tố L: long big = 10000000000L.

Vì sao 0.1 + 0.2 không bằng 0.3?

double và float lưu giá trị ở dạng nhị phân, và 0.1 không có biểu diễn nhị phân chính xác, cũng như một phần ba không có biểu diễn thập phân chính xác. Tổng ra là 0.30000000000000004. Đừng bao giờ so sánh các giá trị dấu phẩy động bằng ==; hãy so sánh hiệu tuyệt đối với một ngưỡng sai số nhỏ.

char là một con số hay một chữ cái?

Cả hai. Một char lưu một số từ 0 đến 65535 xác định một ký tự. Vì nó là một con số, phép tính hoạt động trên nó: 'A' + 1 cho ra int 66. Ép kiểu ngược lại bằng (char) biến 66 thành 'B'.

Ép kiểu và làm tròn khác nhau như thế nào?

Ép một double sang int là cắt bỏ về phía 0 — nó xóa phần thập phân, không làm tròn. (int) 9.99 là 9, và (int) -9.99 là -9, không phải -10. Hãy dùng Math.round khi bạn muốn làm tròn.

Đề 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.