Kiểu dữ liệu trong Java: lưu giá tiền đơn hàng sao cho đúng
Kiểu dữ liệu trong Java gồm int, long, double, String, BigDecimal. Xem vì sao tiền nên dùng long hay BigDecimal, không dùng double, qua ví dụ đơn hàng.
Java có tám kiểu dữ liệu nguyên thủy, và với tiền bạc bạn gần như luôn chọn long (tính bằng đồng) hoặc BigDecimal, không dùng double. Biến là một ô nhớ có tên và có kiểu. Kiểu quyết định ô đó chứa được số lớn đến đâu, và phép tính trên nó cho ra kết quả thế nào.
Ở bài trước, bạn đã chạy được chương trình đầu tiên của quán Mộc (quán cà phê tình huống minh họa mà mình dùng xuyên suốt loạt bài). Nó mới chỉ in ra một dòng "1 ly cà phê sữa, 35000 đồng" bằng chữ. Chưa có chỗ nào để lưu tên khách, số lượng hay giá, và chưa tính được tổng tiền. Muốn làm được, bạn cần biến và kiểu dữ liệu, và cũng chính ở đây có một chuyện mà nhiều người mới tính sai tiền mà không biết.
Biến là gì, và lưu một đơn hàng như thế nào?
Một biến giống một chiếc hộp dán nhãn. Nhãn là tên biến, và hộp chỉ đựng được một loại đồ, đó là kiểu dữ liệu của biến. Khi bạn khai báo int soLuong = 2;, bạn nói với Java ba điều: kiểu là int (số nguyên), tên là soLuong, và giá trị ban đầu là 2.
Mình lưu đơn đầu tiên của chị Lan vào các biến. Tạo file DonDauTien.java (cần gì để chạy thì bạn đã có từ bài trước):
public class DonDauTien {
public static void main(String[] args) {
String khach = "Lan"; // chữ
String mon = "Cà phê sữa";
int soLuong = 2; // số nguyên
long giaMon = 35000; // giá bằng đồng
boolean thanhToanRoi = false; // đúng/sai
long tongTien = soLuong * giaMon; // int nhân long cho ra long
System.out.println("Khách: " + khach);
System.out.println("Món: " + mon + " x " + soLuong);
System.out.println("Tổng tiền: " + tongTien + " đồng");
System.out.println("Đã thanh toán: " + thanhToanRoi);
var ghiChu = "ít đá"; // var: để Java tự suy ra kiểu (ở đây là String)
System.out.println("Ghi chú: " + ghiChu);
}
}java -Dstdout.encoding=UTF-8 DonDauTien.javaKhách: Lan
Món: Cà phê sữa x 2
Tổng tiền: 70000 đồng
Đã thanh toán: false
Ghi chú: ít đáBạn nhìn dòng long tongTien = soLuong * giaMon;. Phép nhân giữa một int và một long cho ra một long, nên kết quả 70000 được lưu vào biến long. Dòng cuối dùng var: bạn không viết kiểu, nhưng Java đọc vế phải ("ít đá" là một chuỗi) và tự biết biến này là String. var chỉ dùng được cho biến cục bộ có giá trị ban đầu, và kiểu của biến vẫn cố định sau đó, nên đây không phải kiểu "động" như một số ngôn ngữ khác.
Java có những kiểu dữ liệu nào?
Java chia kiểu dữ liệu thành hai nhóm. Nhóm thứ nhất là kiểu nguyên thủy (primitive): các giá trị đơn giản được lưu trực tiếp, gồm tám kiểu. Nhóm thứ hai là kiểu tham chiếu, gồm String, mảng, và mọi class bạn sẽ tự viết. String dễ gây nhầm vì nó trông giống như kiểu cơ bản, nhưng thực ra là một class.
Để biết giới hạn của từng kiểu số, mình viết một chương trình in ra kích thước và khoảng giá trị mà Java cho phép:
public class BangKieuDuLieu {
public static void main(String[] args) {
System.out.println("byte " + Byte.BYTES + " byte từ " + Byte.MIN_VALUE + " đến " + Byte.MAX_VALUE);
System.out.println("short " + Short.BYTES + " byte từ " + Short.MIN_VALUE + " đến " + Short.MAX_VALUE);
System.out.println("int " + Integer.BYTES + " byte từ " + Integer.MIN_VALUE + " đến " + Integer.MAX_VALUE);
System.out.println("long " + Long.BYTES + " byte từ " + Long.MIN_VALUE + " đến " + Long.MAX_VALUE);
System.out.println("float " + Float.BYTES + " byte tối đa khoảng " + Float.MAX_VALUE);
System.out.println("double " + Double.BYTES + " byte tối đa khoảng " + Double.MAX_VALUE);
System.out.println("char " + Character.BYTES + " byte một ký tự Unicode, ví dụ 'ộ'");
System.out.println("boolean chỉ có true hoặc false");
}
}byte 1 byte từ -128 đến 127
short 2 byte từ -32768 đến 32767
int 4 byte từ -2147483648 đến 2147483647
long 8 byte từ -9223372036854775808 đến 9223372036854775807
float 4 byte tối đa khoảng 3.4028235E38
double 8 byte tối đa khoảng 1.7976931348623157E308
char 2 byte một ký tự Unicode, ví dụ 'ộ'
boolean chỉ có true hoặc falseCách nhớ nhanh cho người mới: số nguyên thường dùng int và long, số thực dùng double, một chữ cái là char, đúng sai là boolean. byte và short hiếm khi cần trong code backend thông thường. float thì nhiều người quên luôn vì double chính xác hơn và gần như không tốn thêm gì. Bạn có thể đọc bảng đầy đủ ở hướng dẫn kiểu dữ liệu của Oracle.
Con số cần nhớ nhất trong bảng là giới hạn của int: khoảng 2,1 tỷ. Phần dưới sẽ cho thấy vì sao.
Vì sao giá tiền nên dùng long thay vì int?
Quán Mộc tính tiền bằng đồng, không có phần lẻ, nên số nguyên là hợp lý. Câu hỏi là int hay long. Một đơn cà phê vài chục nghìn thì int thừa sức chứa. Nhưng chương trình sẽ còn cộng doanh thu cả ngày, cả tháng, và khi đó con số vượt 2,1 tỷ khá nhanh. Mình thử cộng 2 tỷ với 500 triệu:
int doanhThuThang = 2_000_000_000;
int doanhThuThemVao = 500_000_000;
int tong = doanhThuThang + doanhThuThemVao;
System.out.println("1. int: " + doanhThuThang + " + " + doanhThuThemVao + " = " + tong);
long tongLong = (long) doanhThuThang + doanhThuThemVao;
System.out.println(" long: " + tongLong);
try {
Math.addExact(doanhThuThang, doanhThuThemVao);
} catch (ArithmeticException e) {
System.out.println(" Math.addExact báo lỗi: " + e);
}1. int: 2000000000 + 500000000 = -1794967296
long: 2500000000
Math.addExact báo lỗi: java.lang.ArithmeticException: integer overflowHai số dương cộng lại ra một số âm. Java không báo lỗi nào: khi kết quả vượt quá int, giá trị tự quay vòng về đầu thang. Với một quán cà phê, báo cáo doanh thu âm 1,79 tỷ là loại lỗi dễ lọt qua test vì nó chỉ xảy ra ở con số lớn. Dòng thứ hai cho thấy kết quả đúng khi dùng long. Dòng thứ ba cho thấy cách buộc Java báo lỗi: Math.addExact ném ngoại lệ thay vì quay vòng im lặng, hữu ích ở những chỗ mà sai tiền là điều không được phép.
Vì vậy quy tắc đơn giản của mình: tiền tính bằng đồng thì dùng `long`. Đây cũng là lý do trong miền dữ liệu chung của loạt bài, price là long.
Vì sao không được dùng double để tính tiền?
double lưu số thực theo cách dùng hệ nhị phân, và nhiều số thập phân đơn giản như 0,1 không biểu diễn chính xác được trong hệ nhị phân (giống như 1/3 không viết hết được trong hệ thập phân). Kết quả là sai số cực nhỏ nhưng có thật:
System.out.println("2. 0.1 + 0.2 = " + (0.1 + 0.2));
System.out.println(" 0.1 + 0.2 == 0.3 ? " + (0.1 + 0.2 == 0.3));
// Phụ thu 15% cho món 3000 đồng: đáng ra là 3450
double phuThuDouble = 3000 * 1.15;
System.out.println(" 3000 * 1.15 = " + phuThuDouble + " -> (long) = " + (long) phuThuDouble);
long phuThuNguyen = 3000 * 115 / 100;
System.out.println(" 3000 * 115 / 100 (chỉ dùng số nguyên) = " + phuThuNguyen);2. 0.1 + 0.2 = 0.30000000000000004
0.1 + 0.2 == 0.3 ? false
3000 * 1.15 = 3449.9999999999995 -> (long) = 3449
3000 * 115 / 100 (chỉ dùng số nguyên) = 3450Hai dòng đầu là ví dụ kinh điển: 0.1 + 0.2 không bằng 0.3. Hai dòng sau là chỗ ảnh hưởng đến tiền thật. Món 3.000 đồng phụ thu 15% đáng ra là 3.450 đồng, nhưng 3000 * 1.15 cho 3449.9999999999995. Khi ép về số nguyên bằng (long), Java cắt phần lẻ chứ không làm tròn, nên kết quả thành 3.449, và khách bị tính thiếu 1 đồng.
Mình chạy thử một vòng lặp qua các mức giá là bội của 500 đồng (đoạn thử này không nằm trong repo) và tìm ra tám mức bị lệch như vậy với phụ thu 15%, trong đó có 1.500, 3.000, 3.500 và 6.000. Vòng lặp dừng ở tám, nên số mức bị lỗi còn nhiều hơn, và đây không phải một trường hợp hiếm.
Lỗi 1 đồng nhìn nhỏ, nhưng nó có ba tác hại. Doanh thu cuối ngày không khớp với tổng từng đơn, đối soát với ngân hàng sai lệch, và lỗi chỉ xuất hiện với vài mức giá nên khó tái hiện khi bạn debug. Cách an toàn cho tiền đồng là tính bằng số nguyên: 3000 * 115 / 100 cho đúng 3450.
Chia số nguyên và ép kiểu làm hỏng kết quả như thế nào?
Có hai thứ nữa mà người mới hay vấp. Thứ nhất, / giữa hai số nguyên là phép chia nguyên: phần lẻ bị cắt đi, không làm tròn. Thứ hai, ép từ số thực về số nguyên bằng (int) cũng cắt phần lẻ.
long tongDon = 99999;
System.out.println("3. 99999 / 10 = " + (tongDon / 10) + " (không phải 9999.9)");
System.out.println(" 99999 / 10.0 = " + (tongDon / 10.0));
double giaTri = 3.99;
System.out.println("4. (int) 3.99 = " + (int) giaTri + " Math.round(3.99) = " + Math.round(giaTri));3. 99999 / 10 = 9999 (không phải 9999.9)
99999 / 10.0 = 9999.9
4. (int) 3.99 = 3 Math.round(3.99) = 4Giảm 10% của đơn 99.999 đồng bằng tongDon / 10 cho 9.999, bị cắt mất 0,9 đồng. Việc cắt xuống hay làm tròn là một quyết định nghiệp vụ, không phải chuyện kỹ thuật, và bạn nên hỏi người đặt yêu cầu thay vì để Java tự quyết bằng phép chia. Còn Math.round mới là cách làm tròn thật, cho 4 với 3,99.
Java cũng bảo vệ bạn ở chỗ nguy hiểm hơn: thu hẹp từ long về int mà không ép kiểu rõ ràng thì trình biên dịch từ chối. Mình viết một file cố tình sai tên LoiBienDich.java để xem thông báo:
public class LoiBienDich {
public static void main(String[] args) {
long tongTien = 35000L * 3;
int soTien = tongTien;
System.out.println(soTien);
}
}LoiBienDich.java:5: error: incompatible types: possible lossy conversion from long to int
int soTien = tongTien;
^
1 errorCâu possible lossy conversion nghĩa là "có thể mất thông tin khi chuyển". Java buộc bạn viết (int) tongTien nếu thật sự muốn, để việc có nguy cơ cắt mất dữ liệu luôn là một lựa chọn có chủ ý, không phải sự cố.
Khi nào cần BigDecimal?
Với tiền đồng làm bằng số nguyên là gọn nhất. Nhưng nếu bạn cần tiền có phần lẻ (đô la có cent), hoặc thuế và tỷ lệ với nhiều chữ số thập phân, long không đủ. Lúc đó dùng BigDecimal, một class lưu số thập phân đúng như bạn gõ:
import java.math.BigDecimal;
import java.math.RoundingMode;
public class TienVoiBigDecimal {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
System.out.println("BigDecimal(\"0.1\") + BigDecimal(\"0.2\") = " + a.add(b));
System.out.println("new BigDecimal(0.1) = " + new BigDecimal(0.1));
BigDecimal giaDon = new BigDecimal("99999");
BigDecimal giamGia = giaDon.multiply(new BigDecimal("0.10"));
System.out.println("Giảm 10% của 99999 = " + giamGia);
System.out.println("Làm tròn về đồng = " + giamGia.setScale(0, RoundingMode.HALF_UP));
}
}BigDecimal("0.1") + BigDecimal("0.2") = 0.3
new BigDecimal(0.1) = 0.1000000000000000055511151231257827021181583404541015625
Giảm 10% của 99999 = 9999.90
Làm tròn về đồng = 10000Dòng đầu cho đúng 0.3. Nhưng hãy nhìn dòng thứ hai, một cạm bẫy: new BigDecimal(0.1) (truyền vào một double) cho ra một dãy chữ số dài. Lý do là 0.1 đã bị double làm sai từ trước khi vào BigDecimal, nên BigDecimal chỉ trung thành lưu lại cái sai đó. Cách đúng là truyền chuỗi: new BigDecimal("0.1"). Hai dòng cuối cho thấy cách làm tròn có kiểm soát: bạn chọn rõ RoundingMode.HALF_UP (làm tròn nửa lên), và có thể xem tài liệu của BigDecimal để chọn chế độ phù hợp với quy định của bạn.
Cái giá của BigDecimal là code dài hơn: không thể viết a + b, bạn phải gọi a.add(b), và chạy chậm hơn số nguyên. Vì vậy quy tắc của mình: tiền đồng thì long, tiền có phần lẻ hoặc cần tỷ lệ chính xác thì BigDecimal, và không bao giờ là double.
Bước tiếp theo là gì?
Bạn đã có biến, biết chọn kiểu cho tiền, và tránh được vài cái bẫy.
Nhưng chương trình vẫn chỉ làm đúng một việc theo một đường thẳng: tính tổng đơn. Quán Mộc có quy tắc "đơn từ 100.000 đồng thì giảm 10%", và chương trình chưa biết quyết định gì. Nó cũng chưa biết lặp lại việc tính cho nhiều đơn, hay đặt phép tính vào một hàm để dùng lại. Đó là việc của bài kế tiếp. Bạn có thể xem toàn bộ các bài trong series Học Java từ đầu cho người làm backend.
Nếu bạn đang ôn phỏng vấn, thử trả lời câu vì sao không nên dùng double hoặc float để tính tiền trước khi đọc đáp án.