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

Tìm kiếm

OOP & Thiết kếMid17 phút đọc

Lập trình hướng đối tượng: wrapper class, BigInteger/BigDecimal và String

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

Cụm bài Lập trình hướng đối tượng: 1. Class, object, access modifier · 2. Bất biến, equals/hashCode, final · 3. Kế thừa, đóng gói, đa hình · 4. Abstract class, interface · 5. UML, quan hệ giữa class · 6. Wrapper, BigDecimal, String

Bài này nói về ba nhóm class “nền” mà backend Java dùng hằng ngày nhưng hay dùng sai: wrapper class, BigInteger/BigDecimal và String/StringBuilder. Đọc xong, bạn tránh được các bẫy ==, unbox null, tính tiền sai và nối chuỗi O(n²). Nên đọc trước phần 2 về object bất biến; thiết kế quan hệ giữa các class bằng UML nằm ở phần 5.

Sơ đồ tóm tắt:

mindmap
  root((Wrapper, BigDecimal, String))
    Wrapper
      So bằng equals
      Cache từ -128 đến 127
      Unbox null ném NPE
    BigDecimal cho tiền
      Tạo từ String
      Chia kèm scale, RoundingMode
      So bằng compareTo
    String bất biến
      Vòng lặp dùng StringBuilder

1. Wrapper class

Ý chính: primitive không phải object, nên mỗi primitive có một wrapper class để dùng ở chỗ cần object. Compiler tự chuyển qua lại (autoboxing), và chính sự tự động này sinh ra ba bẫy: ==, unbox null và chi phí tạo object.

Chỗ cần object mà primitive không vào được: generics (List<int> không hợp lệ), giá trị null, các method tiện ích.

Primitive Wrapper Primitive Wrapper
byte Byte float Float
short Short double Double
int Integer char Character
long Long boolean Boolean

Bảng ánh xạ trong slide bị sai: thiếu dòng int, và ghi long → Integer. Đúng là int → Integer, long → Long như bảng trên.

  • Wrapper là class bất biến và final.
  • Autoboxing / unboxing (compiler tự đổi int ↔ Integer): Integer c = a + b; chạy được vì a, b được unbox thành int, cộng, rồi kết quả được box lại.
Integer a = 1, b = 2;
Integer c = a + b;                       // unbox, cộng, rồi box: Integer.valueOf(a.intValue() + b.intValue())

int parsed = Integer.parseInt("42");     // String -> int
Integer boxed = Integer.valueOf("42");   // String -> Integer (có dùng cache)
String bin = Integer.toBinaryString(10); // "1010"
int max = Integer.MAX_VALUE;             // 2147483647
Character.isDigit('7');                  // true
Boolean.parseBoolean("TRUE");            // true (không phân biệt hoa thường)
Double.compare(0.1 + 0.2, 0.3);          // 1

API chung của các wrapper số

Ý chính: các wrapper số (Byte, Short, Integer, Long, Float, Double) đều kế thừa java.lang.Number và implement Comparable, nên có chung bộ method: hằng MIN_VALUE/MAX_VALUE, xxxValue(), compare, valueOf/parseXxx. Overload nhận cơ số (radix) chỉ có ở wrapper số nguyên.

Hai điểm hay nhầm: Double.MIN_VALUE là số dương nhỏ nhất, và thu hẹp kiểu (byteValue(), intValue()) cắt bit hoặc bỏ phần thập phân mà không báo lỗi.

Bảng API wrapper số, overload theo cơ số và cache của Integer
Nhóm Method Ghi chú
Hằng số MIN_VALUE, MAX_VALUE Với Float/Double, MIN_VALUE là số dương nhỏ nhất (4.9E-324), không phải số âm nhỏ nhất. Số âm nhỏ nhất là -Double.MAX_VALUE.
Chuyển đổi (từ Number) byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue() Thu hẹp kiểu thì cắt bit hoặc bỏ phần thập phân: Integer.valueOf(300).byteValue() là 44, Double.valueOf(3.99).intValue() là 3.
So sánh compareTo(other), static compare(a, b) Trả về số âm, 0 hoặc dương.
Chuỗi toString(), static valueOf(String) (trả về wrapper), static parseInt(String) / parseDouble(String)… (trả về primitive) Chuỗi sai định dạng ném NumberFormatException.
Cơ số Integer.parseInt(s, radix), Integer.valueOf(s, radix), Integer.toString(i, radix), tương tự cho Long, Short, Byte Chỉ có ở wrapper số nguyên.
Integer.parseInt("ff", 16);        // 255
Integer.valueOf("1010", 2);        // 10
Integer.toString(255, 2);          // "11111111"
Long.parseLong("zz", 36);          // 1295
Integer.valueOf(5).compareTo(7);   // -1
Double.valueOf(9.75).intValue();   // 9

2. BigInteger và BigDecimal

Ý chính: long chỉ tới khoảng 9,2 × 10¹⁸ và double không chính xác. Cần số nguyên cực lớn thì dùng BigInteger, cần số thập phân chính xác (tiền) thì dùng BigDecimal.

  • BigInteger: số nguyên độ lớn tuỳ ý, chỉ giới hạn bởi bộ nhớ. Dùng cho mật mã (RSA), giai thừa lớn, ID cực lớn.
  • BigDecimal: một BigInteger (unscaled value, phần số nguyên bên trong) cộng một scale (số chữ số sau dấu phẩy). Đây là chuẩn để tính tiền.
  • Cả hai bất biến; phép tính dùng method (add, subtract, multiply, divide, remainder/mod, pow), kết quả phải gán lại.
BigInteger big = BigInteger.TWO.pow(100);                 // 1267650600228229401496703205376
BigInteger r = new BigInteger("123456789123456789").mod(BigInteger.valueOf(97));

BigInteger[] qr = BigInteger.valueOf(17).divideAndRemainder(BigInteger.valueOf(5));   // [3, 2]: thương và dư trong một lần chia
BigInteger p = BigInteger.probablePrime(64, new SecureRandom());   // số nguyên tố ngẫu nhiên 64 bit (xác suất sai cực nhỏ)
BigInteger next = BigInteger.valueOf(100).nextProbablePrime();      // 101

BigDecimal price = new BigDecimal("19.99");               // tạo từ String
BigDecimal qty = BigDecimal.valueOf(3);
BigDecimal total = price.multiply(qty);                    // 59.97
total = total.add(new BigDecimal("0.03"));                 // 60.00 (phải gán lại vì bất biến)

Những bẫy của BigDecimal mà phỏng vấn senior hay hỏi:

Chọn RoundingMode chưa đủ; còn phải chọn làm tròn ở đâu. VAT 10% trên ba dòng 333.333đ: làm tròn VAT từng dòng rồi cộng được 99.999đ, làm tròn VAT của tổng được 100.000đ. Bài Đặt vé máy bay: booking, ledger và lịch sử (pitfall “tổng các dòng VAT đã làm tròn khác VAT của tổng”) giải thích vì sao 1 đồng lệch đó làm đối soát báo lỗi hàng ngày, và cách chốt một quy tắc làm tròn duy nhất.

Áp dụng trong Spring: bài giỏ hàng và đặt hàng lưu tiền bằng BigDecimal, chụp giá vào từng dòng đơn lúc đặt và tính tổng đơn từ các dòng ở đúng một chỗ.

3. String, StringBuilder (và StringBuffer)

Ý chính: String bất biến: mọi method “sửa” (concat, replace, toUpperCase, substring…) trả về chuỗi mới. Cần sửa nhiều lần, như ghép chuỗi trong vòng lặp, thì dùng StringBuilder, một chuỗi sửa được tại chỗ.

Vì sao String bất biến:

  • String pool (vùng các literal giống nhau dùng chung một object): chia sẻ chỉ an toàn khi không ai sửa được chuỗi.
  • Bảo mật: đường dẫn file, URL, tên class đã truyền đi thì không bị sửa ngầm.
  • Thread-safe và cache được hash, nên chuỗi là key tốt cho HashMap.
String s1 = "hi";
String s2 = "hi";                 // cùng object trong pool với s1
String s3 = new String("hi");     // object mới trên heap
s1 == s2;          // true
s1 == s3;          // false
s1.equals(s3);     // true: luôn dùng equals để so sánh chuỗi
s1 == s3.intern(); // true: intern() trả về bản trong pool

StringBuilder: append, insert, delete, deleteCharAt, replace, reverse, setCharAt sửa trực tiếp một mảng ký tự bên trong, mảng tự nới khi đầy. Các method trả về chính sb nên gọi nối tiếp được.

StringBuilder sb = new StringBuilder("abc");
sb.reverse().insert(0, '>').append(42);   // ">cba42": các method trả về chính sb nên gọi nối tiếp được
String result = sb.toString();

StringBuilder hello = new StringBuilder("Hello, World");
hello.deleteCharAt(5);           // "Hello World": xoá một ký tự theo vị trí
hello.replace(0, 5, "Hi");       // "Hi World": thay đoạn [0, 5), cận cuối không tính
hello.replace(2, 100, "!");      // "Hi!": end vượt quá độ dài thì được cắt về length()
Bên trong String: compact strings, string pool trên heap, method mới

Bài tập

Code đã chạy thử trên JDK 21.

1. Viết code dùng các method của wrapper, String, StringBuilder, BigInteger, BigDecimal

Đề: viết một đoạn code gọi các method tiêu biểu của từng class và in kết quả, để tự kiểm tra cache, cơ số, mod, làm tròn tiền.

Lời giải Bài 1: code chạy trên JDK 21 kèm output
// Wrapper
int n = Integer.parseInt("2024");
Integer cached1 = 100, cached2 = 100;
System.out.println(cached1 == cached2);                    // true (nằm trong cache)
System.out.println(Integer.valueOf(1000).equals(1000));    // true
System.out.println(Integer.toHexString(255) + " " + Long.MAX_VALUE + " " + Character.toUpperCase('a'));
System.out.println(Integer.compare(3, 7) + " " + Integer.sum(3, 7) + " " + Integer.bitCount(7));
System.out.println(Integer.valueOf(1000).doubleValue() + " " + Double.valueOf(9.75).intValue());   // 1000.0 9
System.out.println(Integer.parseInt("777", 8) + " " + Integer.toString(255, 16) + " " + Integer.MIN_VALUE);   // 511 ff -2147483648

// String
String s = "  Backend Java  ";
System.out.println(s.strip().toLowerCase().replace("java", "Spring"));   // "backend Spring"
System.out.println("a,b,,c".split(",").length);           // 4
System.out.println("ha".repeat(3) + " " + "abc".contains("b") + " " + "abc".indexOf('c'));
System.out.println(String.join("-", List.of("2026", "11", "17")));       // 2026-11-17
System.out.println("Xin chào %s, bạn %d tuổi".formatted("Vinh", 28));

// StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) sb.append(i).append(i < 5 ? "," : "");
sb.insert(0, '[').append(']');
System.out.println(sb + " " + sb.length() + " " + sb.reverse());         // [1,2,3,4,5] 11 ]5,4,3,2,1[
sb.reverse().deleteCharAt(0).replace(sb.length() - 1, sb.length(), "");
System.out.println(sb);                                                   // 1,2,3,4,5

// BigInteger: 30! vượt xa long
BigInteger fact = BigInteger.ONE;
for (int i = 2; i <= 30; i++) fact = fact.multiply(BigInteger.valueOf(i));
System.out.println(fact + " " + fact.bitLength() + " bits " + BigInteger.valueOf(97).isProbablePrime(20));
BigInteger[] qr = fact.divideAndRemainder(BigInteger.valueOf(1_000_000_007));
System.out.println(qr[1] + " " + BigInteger.valueOf(-7).mod(BigInteger.valueOf(5)) + " " + BigInteger.valueOf(1000).nextProbablePrime());   // 109361473 3 1009

// BigDecimal: tính tiền
BigDecimal price = new BigDecimal("199000");
BigDecimal vat = price.multiply(new BigDecimal("0.08")).setScale(0, RoundingMode.HALF_UP);
BigDecimal perPerson = price.add(vat).divide(BigDecimal.valueOf(3), 0, RoundingMode.HALF_EVEN);
System.out.println(vat + " " + price.add(vat) + " " + perPerson);        // 15920 214920 71640
System.out.println(new BigDecimal("1.10").stripTrailingZeros().toPlainString());   // 1.1

Ghi nhớ

  • Giải thích được vì sao Integer a = 127, b = 127; a == b là true mà với 128 là false.
  • Biết chỗ nào unbox null có thể xảy ra (map, JPA, JSON) và vì sao new Integer(..) bị deprecated.
  • Viết đúng phép chia BigDecimal và giải thích được equals khác compareTo thế nào.
  • Phân biệt được BigInteger.mod và remainder, và biết dùng cái nào cho shard index.
  • Giải thích được vì sao nối chuỗi trong vòng lặp là O(n²) và khi nào + vẫn ổn.

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

Junior

Wrapper class là gì? Autoboxing là gì?

Wrapper là class bọc một giá trị primitive (Integer bọc int…); autoboxing/unboxing là compiler tự chuyển qua lại giữa hai dạng.

Wrapper dùng được ở những chỗ cần object, như generics hay giá trị null. Bên dưới, autoboxing là lời gọi valueOf(), unboxing là intValue().

Vì sao String bất biến?

Để dùng chung an toàn trong string pool, để tham số nhạy cảm không bị sửa ngầm, để thread-safe và cache được hash.

Tham số nhạy cảm là đường dẫn, URL, tên class. Hash được cache nên chuỗi là key tốt cho HashMap.

Mid

String, StringBuilder và StringBuffer khác nhau thế nào? Khi nào dùng cái nào?

String bất biến; StringBuilder sửa được, không thread-safe, nhanh; StringBuffer sửa được, thread-safe nhờ synchronized, chậm hơn và hiếm khi cần.

Ghép chuỗi trong vòng lặp thì dùng StringBuilder (hoặc String.join, Collectors.joining). Nối trong một biểu thức đơn lẻ thì dùng + vì compiler đã tối ưu.

Integer a = 1000, b = 1000; a == b cho kết quả gì? Còn int c = mapOfInteger.get("missing"); thì sao?

Câu đầu cho false, câu sau ném NullPointerException.

1000 nằm ngoài cache -128 tới 127 nên a và b là hai object khác nhau. Câu sau unbox giá trị null.

Vì sao không dùng double để tính tiền? Dùng BigDecimal thế nào cho đúng?

double là số nhị phân, không biểu diễn chính xác được 0,1, nên sai số tích luỹ dần; BigDecimal thì chính xác nếu dùng đúng cách.

  • Tạo từ String hoặc valueOf.
  • Phép chia phải chỉ rõ scale và RoundingMode.
  • So sánh bằng compareTo (vì equals so cả scale).
  • Thống nhất quy tắc làm tròn với nghiệp vụ; cột DB dùng NUMERIC/DECIMAL.
new Integer(5) và Integer.valueOf(5) khác nhau thế nào? Vì sao constructor của wrapper bị deprecated?

new Integer(5) luôn tạo object mới; Integer.valueOf(5) trả về object có sẵn trong cache (-128 tới 127), nên tiết kiệm bộ nhớ và == giữa hai lần gọi cho true.

Constructor bị deprecated từ Java 9 và đánh dấu xoá từ Java 16. Nó buộc tạo object mới mỗi lần, cản trở cache và cản trở hướng biến wrapper thành value class (Project Valhalla), nơi “danh tính” của object không còn ý nghĩa. Dùng valueOf, parseInt hoặc autoboxing.

BigInteger.remainder và BigInteger.mod khác nhau ra sao?

remainder mang dấu của số bị chia (giống %); mod luôn không âm, trong [0, m).

-7 remainder 5 = -2, -7 mod 5 = 3. mod ném ArithmeticException nếu modulus không dương. Cần cả thương và dư thì dùng divideAndRemainder, chỉ chia một lần.

Senior

BigDecimal dùng làm key trong HashMap hoặc HashSet có vấn đề gì?

equals/hashCode tính cả scale, nên 2.0 và 2.00 là hai key khác nhau, trong khi compareTo coi chúng bằng nhau.

TreeMap dùng compareTo nên gộp chúng làm một; HashMap thì không. Cách xử lý: chuẩn hoá bằng stripTrailingZeros() hoặc setScale cố định trước khi làm key, hoặc dùng TreeMap.

Bạn nối chuỗi để build một file CSV vài triệu dòng. Có những lưu ý gì về hiệu năng và bộ nhớ?

Đừng build cả file trong bộ nhớ: stream từng dòng ra BufferedWriter hoặc thẳng vào response output stream.

  • Không dùng += trong vòng lặp (O(n²)). Một StringBuilder cho cả file cũng có thể giữ hàng trăm MB trên heap.
  • Đặt sẵn capacity hợp lý cho StringBuilder của từng dòng.
  • Escape ký tự đặc biệt của CSV và chỉ rõ UTF-8.
  • Export qua HTTP thì dùng streaming response để không chặn bộ nhớ và không bị timeout.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng khi phỏng vấn
boxing / unboxing /ˈbɑːksɪŋ/ đóng gói / mở gói primitive “Unboxing a null Integer throws a NullPointerException.”
arbitrary precision /ˈɑːrbɪtreri prɪˈsɪʒn/ độ chính xác tuỳ ý “BigDecimal gives arbitrary precision for monetary values.”
rounding mode /ˈraʊndɪŋ moʊd/ chế độ làm tròn “We use HALF_EVEN as the rounding mode for aggregated reports.”
string pool /strɪŋ puːl/ vùng chứa chuỗi dùng chung “String literals are interned in the string pool.”
mutable /ˈmjuːtəbl/ thay đổi được “StringBuilder is mutable and not thread-safe.”
radix /ˈreɪdɪks/ cơ số (2, 8, 16…) “parseInt takes an optional radix, so I can parse hex without a regex.”
deprecated for removal /ˈdeprəkeɪtɪd/ bị đánh dấu sẽ xoá “The wrapper constructors are deprecated for removal, so we use valueOf.”
immutable /ɪˈmjuːtəbl/ bất biến “Wrappers are immutable, so x++ on an Integer creates a new object.”
unscaled value /ʌnˈskeɪld/ phần số nguyên bên trong BigDecimal “A BigDecimal is an unscaled BigInteger plus a scale.”

Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer), viết lại theo cách hiểu của mình. Sách tham khảo của slide: Y. Daniel Liang, Introduction to Java Programming and Data Structures (bản 11), nhiều sơ đồ trong slide lấy từ sách này.