Varargs — nhận số tham số tùy ý

String.format, List.of, Arrays.asList, Collections.addAll, System.out.printf — tất cả đều nhận số lượng argument tuỳ ý. Bạn có thể gọi of(), of(1), of(1, 2, 3, 4, 5). Java gọi tính năng đó là varargs (variable arguments). Nhìn giống magic, thực chất compiler đóng gói các argument vào một mảng rồi truyền vào.

Bài này giải thích cú pháp, cơ chế biến đổi sang mảng, rule "chỉ 1 varargs và phải cuối", và những bẫy khi varargs gặp overload hoặc generics.

1. Analogy — ổ cắm đa năng

Ổ cắm thường có 2 lỗ — đúng 2 chân dây, thiếu hoặc thừa đều không cắm được. Ổ cắm đa năng (multi-plug) chấp nhận 0, 1, 5, 10 thiết bị — bạn cắm bao nhiêu cũng được, miễn dưới giới hạn.

2. Cú pháp

public static int sum(int... nums) {
    int total = 0;
    for (int n : nums) total += n;
    return total;
}

sum();            // 0
sum(5);           // 5
sum(1, 2, 3);     // 6
sum(new int[]{4, 5, 6});  // 15 — truyen mang co san

Dấu ... đặt sau kiểu, trước tên parameter. Bên trong method, nums là mảng int[] thực sự — bạn dùng nó như mảng bình thường: nums.length, nums[i], for-each.

2.1 Rule 1 — chỉ 1 varargs trong 1 method

public static void f(int... a, int... b) { ... }   // COMPILE ERROR

Vì compiler không biết chia argument nào cho a, argument nào cho b.

2.2 Rule 2 — varargs phải ở cuối parameter list

public static void log(String... tags, String message) { ... }   // COMPILE ERROR
public static void log(String message, String... tags) { ... }   // OK

Tương tự lý do: compiler cần biết đâu là tham số bắt buộc, đâu là varargs. Parameter cố định đi trước, varargs gom phần dư.

log("ERROR");                        // message = "ERROR", tags = []
log("ERROR", "auth", "network");     // message = "ERROR", tags = ["auth", "network"]

3. Cơ chế bên dưới — thực ra là mảng

Bytecode đóng gói varargs thành mảng tại call site. Ví dụ:

// Source:
sum(1, 2, 3);

// Tuong duong voi:
sum(new int[]{1, 2, 3});

sum method có signature int sum(int[]) ở bytecode. Dấu ... là đường cú pháp (syntactic sugar) cho người viết, không cho JVM. Điều này có hệ quả:

1. Bạn có thể truyền mảng sẵn có vào method varargs — Java không bắt buộc expand:

   int[] arr = {10, 20, 30};
   int s = sum(arr);   // OK, khong unwrap roi wrap lai
   

2. Method varargs gọi từ class khác compile thành invokevirtual sum([I)I — nhận int[], return int.
3. nums.length == 0 khi gọi sum() không argument — không null, là mảng rỗng.

4. Varargs + overload — bẫy "ambiguous"

public static void show(int a, int b)    { System.out.println("two"); }
public static void show(int... xs)       { System.out.println("vararg"); }

show(1, 2);   // in "two" — fixed-arity thang varargs
show(1);      // in "vararg"
show();       // in "vararg"

Rule từ bài overloading: fixed-arity luôn thắng varargs nếu cả hai applicable.

Nhưng khi có 2 varargs method cùng applicable:

public static void f(Object... xs)  { System.out.println("Object"); }
public static void f(String... xs)  { System.out.println("String"); }

f("a", "b");   // in gi?

• Cả hai applicable: String[] là subtype của Object[].
• Compiler dùng rule "most specific": String[] cụ thể hơn Object[] → chọn f(String...) → in "String".

f();   // in gi? AMBIGUOUS — compile error

Với 0 argument, cả Object[]{} và String[]{} đều match, không ai "more specific" hơn từ 0 phần tử → compile error. Fix: cast rõ f((String[]) null).

5. Varargs + generics — warning "unchecked"

public static <T> List<T> asList(T... items) {
    return Arrays.asList(items);
}

asList("a", "b");      // warning: unchecked generic array creation
asList(1, 2, 3);        // warning same

Vấn đề: Java không cho phép tạo new T[] (generic array) do type erasure — ở runtime T[] thành Object[]. Varargs với T buộc compiler tạo array generic → compiler ném warning "unchecked" báo bạn chịu trách nhiệm đảm bảo type safety.

Cách xử lý:

// Trong JDK, cac method nhu Arrays.asList bao dam an toan
// va danh dau @SafeVarargs de tat warning

@SafeVarargs
public static <T> List<T> asList(T... items) {
    return new ArrayList<>(Arrays.asList(items));
}

@SafeVarargs nói với compiler: "Tôi đã kiểm tra, method này không làm hành động unsafe với generic array". Chỉ đặt lên method static, final, hoặc private (phương án mà không ai override được).

6. Khi nào dùng varargs?

✅ Nên khi:

• Method logic tự nhiên nhận 0 đến nhiều argument cùng kiểu: List.of, String.format, Collections.addAll.
• Call site gọn hơn hẳn viết new T[]{...}: log("A", "B", "C") dễ đọc hơn log(new String[]{"A", "B", "C"}).

❌ Tránh khi:

• Hot-path perf-critical — mỗi call allocate mảng mới.
• Ý nghĩa argument khác nhau → dùng record hoặc builder thay vì dồn vào Object....
• Có thể gây ambiguous overload (đã nói ở phần 4).

7. Truyền mảng sẵn vào varargs — lưu ý

public static int sum(int... nums) { ... }

int[] arr = {1, 2, 3};
sum(arr);   // nums = arr (cung tham chieu, khong copy)

int[][] matrix = {{1, 2}, {3, 4}};
sum(matrix);   // COMPILE ERROR — int[][] khong match int...

Khi truyền mảng sẵn, Java dùng nó trực tiếp (không wrap lần nữa). Đây là tối ưu, nhưng có hệ quả: method có thể sửa mảng gốc.

public static void zeroOut(int... nums) {
    for (int i = 0; i < nums.length; i++) nums[i] = 0;
}

int[] data = {1, 2, 3};
zeroOut(data);
System.out.println(Arrays.toString(data));   // [0, 0, 0]

Nếu không muốn mảng gốc bị sửa, clone trước: zeroOut(data.clone()).

8. Pitfall tổng hợp

❌ Nhầm 1: Đặt varargs không ở cuối.

void f(int... xs, String name) { ... }   // COMPILE ERROR

✅ Varargs luôn ở cuối. Tham số bắt buộc trước.

❌ Nhầm 2: nums == null khi gọi không argument.

void f(int... nums) {
    if (nums == null) ...   // KHONG bao gio true khi goi f()
}

✅ nums là mảng rỗng int[0], không phải null. Nhưng có thể là null nếu người gọi ép f((int[]) null). Nếu cần defensive, kiểm tra nums == null vẫn có lý.

❌ Nhầm 3: Tưởng varargs rẻ tiền, spam trong loop.

for (int i = 0; i < 1_000_000; i++) log("iter", "n=" + i);   // 2M String[] allocation

✅ Trong hot path, overload fixed-arity hoặc dùng StringBuilder + fixed method.

❌ Nhầm 4: @SafeVarargs trên method không static/final/private.

@SafeVarargs
public <T> void m(T... xs) { ... }   // WARNING — instance method khong final co the override

✅ Chỉ đặt trên static, final, hoặc private.

❌ Nhầm 5: Object... args với Object[] đi vào.

void log(Object... args) { System.out.println(args.length); }

Object[] arr = {"a", "b"};
log(arr);        // in 2 — arr dung lam varargs
log((Object) arr);   // in 1 — arr la 1 phan tu Object

✅ Cast (Object) để buộc 1 argument, hoặc cast (Object[]) để buộc unwrap.

9. 📚 Deep Dive Oracle

10. Tóm tắt

• T... = variable arity parameter. Compiler gom argument vào mảng T[].
• Chỉ 1 varargs mỗi method, phải ở cuối parameter list.
• Call f() không argument → xs là mảng rỗng (không null).
• Có thể truyền mảng sẵn — method có thể sửa mảng gốc (cùng reference).
• Fixed-arity luôn thắng varargs khi cùng applicable. Giữa 2 varargs, rule "most specific".
• Varargs + generics → warning unchecked. Dùng @SafeVarargs khi chắc chắn an toàn, chỉ trên static/final/private.
• Mỗi call varargs tạo một mảng mới — tránh trong hot-path.
• Overload f(T...) với f(T, T) + f(T, T, T) là pattern chuẩn khi cần vừa tiện vừa perf.

11. Tự kiểm tra

public static void log(String... tags, String message) { ... }

public static int sum(int... nums) {
    int t = 0; for (int n : nums) t += n; return t;
}

System.out.println(sum());
System.out.println(sum(new int[]{10, 20, 30}));

public static void f(int a, int b)   { System.out.println("fixed"); }
public static void f(int... xs)      { System.out.println("var"); }

f(1, 2);
f(1, 2, 3);

public static <T> List<T> asList(T... items) {
    return new ArrayList<>(Arrays.asList(items));
}

@SafeVarargs
public static <T> List<T> asList(T... items) {
    return new ArrayList<>(Arrays.asList(items));
}

public static void show(Object... args) {
    System.out.println(args.length);
}

Object[] arr = {"a", "b", "c"};
show(arr);
show((Object) arr);

Bài tiếp theo: Recursion — method gọi chính nó