Primitive types và reference types trong Java khác nhau thế nào?

Question

Accepted Answer

Java có hai nhóm kiểu cơ bản: **primitive** (giá trị đơn giản lưu trực tiếp) và **reference type** (object, trong đó biến giữ một reference/con trỏ tới object). Chúng hành xử rất khác nhau về bộ nhớ, phép gán và so sánh. ## 8 kiểu primitive ```java int i = 42; // số nguyên 32-bit long l = 100L; // số nguyên 64-bit double d = 3.14; // số thực dấu phẩy động 64-bit float f = 1.5f; // số thực dấu phẩy động 32-bit boolean b = true; // true/false char c = 'A'; // ký tự Unicode 16-bit byte by = 127; // 8-bit short s = 1000; // 16-bit ``` Primitive lưu trực tiếp **giá trị thực**, có kích thước cố định, không thể null, và nằm trên stack (với biến cục bộ). Chúng nhanh và tiết kiệm bộ nhớ. ## Reference type — object ```java String name = "Ann"; // reference tới một object String int[] arr = {1, 2, 3}; // reference tới một object array List list = new ArrayList<>(); // reference tới một object List Person p = new Person("Bob"); // reference tới một object Person ``` Biến reference giữ một **reference** (địa chỉ bộ nhớ) tới object được lưu trên heap — không phải chính object đó. Chúng có thể là `null`. ## Khác biệt then chốt: phép gán và so sánh ```java // primitive — phép gán SAO CHÉP giá trị (độc lập) int a = 5; int b = a; // b là một BẢN SAO b = 10; // a vẫn là 5 // reference — phép gán SAO CHÉP reference (cả hai trỏ tới CÙNG một object) int[] x = {1, 2, 3}; int[] y = x; // y trỏ tới CÙNG một array y[0] = 99; // x[0] giờ cũng là 99! (object dùng chung) ``` ```java // == so sánh GIÁ TRỊ với primitive, nhưng so sánh REFERENCE (identity) với object String s1 = new String("hi"); String s2 = new String("hi"); s1 == s2; // false — khác object (khác reference) s1.equals(s2); // true — equals() so sánh NỘI DUNG ``` Đây là một cái bẫy lớn: **`==` trên object so sánh identity (cùng object không?), không phải nội dung** — dùng `.equals()` để so sánh nội dung. ## Wrapper class làm cầu nối giữa hai loại ```java Integer boxed = 42; // Integer là wrapper OBJECT cho int (autoboxing) int unboxed = boxed; // auto-unboxing trở lại primitive List nums; // collection cần object, không phải primitive ``` Mỗi primitive có một wrapper class (`int`→`Integer`, v.v.) để primitive có thể được dùng ở nơi yêu cầu object (collection, generics). ## Tại sao điều này quan trọng Sự phân biệt primitive-và-reference là nền tảng của Java và là nguồn gốc của nhiều bug và hành vi tinh vi: phép gán sao chép giá trị với primitive nhưng dùng chung reference với object (nên sửa một object dùng chung sẽ ảnh hưởng tới mọi reference), và đặc biệt là **`==` so sánh identity với object** (một lỗi kinh điển — dùng `.equals()` để so sánh nội dung). Hiểu điều này ảnh hưởng đến tính đúng đắn trong so sánh, tham số phương thức (object thực chất được truyền theo giá trị của reference), xử lý null (chỉ reference mới có thể null), và hiệu năng (primitive nhẹ hơn). Đây là kiến thức cốt lõi để viết Java đúng.