Varargs Java: Method yang Menerima Argumen Berapa Pun

Satu Method, Argumen Berapa Pun

Kadang kamu tidak tahu sejak awal berapa argumen yang dibutuhkan sebuah method. Mungkin suatu saat kamu ingin max(3, 9), lalu di saat lain max(1, 7, 4, 2, 8). Tanpa varargs, kamu harus menulis overload untuk setiap jumlah argumen atau memaksa pemanggil membuat array. Varargs, singkatan dari variable arguments, membuat satu method bisa menerima nol, satu, atau banyak nilai dengan tipe yang sama.

Kamu mendeklarasikannya dengan menaruh tiga titik (...) setelah tipe parameternya:

public class Main {
    static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) {   // numbers is just an int[]
            total += n;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(1, 2, 3));        // 6
        System.out.println(sum(10, 20));         // 30
        System.out.println(sum());               // 0 - zero args is allowed
        System.out.println(sum(4, 8, 15, 16));   // 43
    }
}

Pemanggil mengirim nilai-nilai lepas; di dalam method, numbers adalah array sungguhan. Itulah seluruh idenya: compiler membungkus argumen-argumen itu ke dalam array untukmu.

Varargs Hanyalah Array

Tidak ada sihir saat runtime. Parameter yang dideklarasikan int... numbers persis sama dengan int[] begitu kamu berada di dalam method. Kamu bisa menanyakan length-nya, mengakses indeksnya, dan melakukan loop padanya seperti array lainnya.

public class Main {
    static String join(String separator, String... parts) {
        if (parts.length == 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder(parts[0]);
        for (int i = 1; i < parts.length; i++) {
            sb.append(separator).append(parts[i]);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        System.out.println(join("-", "2026", "06", "04"));  // 2026-06-04
        System.out.println(join(", ", "alone"));            // alone
    }
}

Karena memang benar-benar array, kamu juga bisa memberikan array yang sudah kamu punya ke method varargs. Method itu menerima kedua bentuk:

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

    public static void main(String[] args) {
        int[] data = {5, 10, 15};
        System.out.println(sum(data));        // pass an existing array
        System.out.println(sum(1, 2, 3, 4));  // or loose values
    }
}

Aturannya: Terakhir dan Hanya Satu

Dua aturan menjaga varargs tetap tidak ambigu, dan compiler menegakkan keduanya:

1. Parameter varargs harus berada di urutan terakhir. Parameter biasa ditulis lebih dulu, lalu parameter ... menampung sisanya.
2. Sebuah method maksimal punya satu parameter varargs. Kalau ada dua, mustahil menentukan di mana yang satu berakhir dan yang berikutnya dimulai.

public class Main {
    // OK: regular parameter first, varargs last
    static void log(String level, Object... values) {
        System.out.print("[" + level + "] ");
        for (Object v : values) {
            System.out.print(v + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        log("INFO", "user", 42, true);
        log("WARN");   // the varargs part can be empty
    }
}

Kode ini berhasil di-compile. Tapi menaruh varargs di depan, misalnya static void log(Object... values, String level), adalah error kompilasi: varargs parameter must be the last. Parameter wajib level selalu ditulis sebelum ....

Tempat Kamu Sudah Memakai Varargs

Sebenarnya kamu sudah memanggil method varargs selama ini. System.out.printf dan String.format adalah contoh klasiknya: parameter keduanya adalah Object... args:

public class Main {
    public static void main(String[] args) {
        System.out.printf("%s scored %d points (%.1f%%)%n", "Ada", 95, 95.0);

        String row = String.format("%-8s | %5d", "banana", 30);
        System.out.println(row);
    }
}

List.of(...), Arrays.asList(...), dan banyak API bergaya builder juga memakai varargs. Itulah sebabnya kamu bisa memberikan elemen berapa pun ke method-method itu tanpa harus membungkusnya sendiri ke dalam array.

Varargs dan Overloading

Varargs dan overloading saling berinteraksi dengan satu cara yang mengejutkan. Kalau overload biasa dan overload varargs sama-sama cocok dengan sebuah panggilan, Java memilih yang lebih spesifik, yaitu method dengan jumlah parameter tetap yang menang:

public class Main {
    static String pick(int a, int b) {
        return "two-arg version";
    }

    static String pick(int... nums) {
        return "varargs version";
    }

    public static void main(String[] args) {
        System.out.println(pick(1, 2));      // two-arg version (more specific)
        System.out.println(pick(1, 2, 3));   // varargs version
        System.out.println(pick());          // varargs version
    }
}

pick(1, 2) cocok dengan keduanya, tetapi Java memilih overload yang bukan varargs karena paling pas. Method varargs hanya berjalan kalau tidak ada overload tetap yang cocok. Biasanya memang itu yang kamu mau, tetapi artinya menambahkan overload varargs bisa diam-diam mengubah method mana yang dipilih untuk sebuah panggilan.

Hati-hati dengan Panggilan Kosong dan null

Ada dua jebakan yang sering menjebak orang. Pertama, memanggil method varargs tanpa argumen memberi method itu array kosong, bukan null, jadi numbers.length bernilai 0 dan loop tidak melakukan apa-apa. Kamu tidak perlu mengecek null untuk kasus tanpa argumen:

public class Main {
    static int count(Object... items) {
        return items.length;   // 0 for count(), never an NPE
    }

    public static void main(String[] args) {
        System.out.println(count());            // 0
        System.out.println(count("a", "b"));    // 2
    }
}

Kedua, mengirim literal null itu ambigu dan berbahaya: Java bisa menafsirkan count(null) sebagai "seluruh array varargs bernilai null", bukan "satu elemen null", yang lalu melempar NullPointerException saat kamu membaca length-nya. Kalau kamu memang bermaksud mengirim satu elemen null, tulis secara eksplisit dengan count((Object) null).

Berikutnya: Class

Varargs melengkapi apa yang bisa kamu lakukan dengan parameter method: daftar argumen yang fleksibel di atas overloading. Sejauh ini method-method kita hidup lepas di dalam class dengan static. Berikutnya kamu akan melihat cara class bekerja yang sebenarnya: menggabungkan data (field) dan perilaku (method) ke dalam tipe buatanmu sendiri, yang menjadi inti dari Java berorientasi objek.