Varargs w Javie: metody przyjmujące dowolną liczbę argumentów

Jedna metoda, dowolna liczba argumentów

Czasem nie wiesz z góry, ilu argumentów potrzebuje metoda. Raz chcesz max(3, 9), a za chwilę max(1, 7, 4, 2, 8). Bez varargs musiałbyś pisać przeciążenie dla każdej liczby argumentów albo zmuszać wywołującego do budowania tablicy. Varargs (skrót od variable arguments, czyli zmienna liczba argumentów) pozwalają jednej metodzie przyjąć zero, jedną albo wiele wartości tego samego typu.

Deklarujesz je, stawiając trzy kropki (...) po typie parametru:

public class Main {
    static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) {   // numbers to po prostu 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 argumentów też jest dozwolone
        System.out.println(sum(4, 8, 15, 16));   // 43
    }
}

Wywołujący przekazuje luźne wartości, a wewnątrz metody numbers to prawdziwa tablica. Na tym polega cały pomysł: kompilator pakuje argumenty w tablicę za ciebie.

Varargs to po prostu tablica

W czasie działania nie ma tu żadnej magii. Parametr zadeklarowany jako int... numbers jest wewnątrz metody dokładnie tablicą int[]. Możesz sprawdzić jej length, sięgać do elementów po indeksie i przechodzić ją pętlą jak każdą inną tablicę.

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
    }
}

Skoro to naprawdę tablica, metodzie z varargs możesz też przekazać tablicę, którą już masz. Przyjmuje obie formy:

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));        // przekazujesz istniejącą tablicę
        System.out.println(sum(1, 2, 3, 4));  // albo luźne wartości
    }
}

Zasady: na końcu i tylko jeden

Dwie zasady sprawiają, że varargs są jednoznaczne, a kompilator pilnuje obu:

1. Parametr varargs musi być ostatni. Najpierw zwykłe parametry, potem parametr ... zgarnia wszystko, co zostało.
2. Metoda może mieć najwyżej jeden parametr varargs. Przy dwóch nie dałoby się ustalić, gdzie kończy się jeden, a zaczyna drugi.

public class Main {
    // OK: najpierw zwykły parametr, varargs na końcu
    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");   // część varargs może być pusta
    }
}

To się kompiluje. Ale postawienie varargs na początku, static void log(Object... values, String level), to błąd kompilacji: varargs parameter must be the last. Wymagany parametr level zawsze stoi przed ....

Gdzie już używasz varargs

Metody z varargs wywołujesz od samego początku. System.out.printf i String.format to klasyczne przykłady: ich drugi parametr to 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(...) i wiele API w stylu buildera to również varargs. Dlatego możesz przekazać im dowolną liczbę elementów, bez samodzielnego opakowywania czegokolwiek w tablicę.

Varargs a przeciążanie

Varargs i przeciążanie współdziałają w jeden zaskakujący sposób. Gdy do wywołania pasuje i zwykłe przeciążenie, i przeciążenie z varargs, Java wybiera bardziej konkretne: wygrywa metoda o stałej liczbie parametrów:

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 (bardziej konkretna)
        System.out.println(pick(1, 2, 3));   // varargs version
        System.out.println(pick());          // varargs version
    }
}

pick(1, 2) pasuje do obu, ale Java wybiera przeciążenie bez varargs, bo pasuje lepiej. Metoda z varargs uruchamia się tylko wtedy, gdy nie pasuje żadne przeciążenie o stałej liczbie parametrów. Zwykle o to właśnie chodzi, ale oznacza to, że dodanie przeciążenia z varargs może po cichu zmienić, która metoda zostanie wywołana.

Uważaj na puste wywołania i null

Dwie pułapki często zaskakują. Po pierwsze, wywołanie metody z varargs bez argumentów przekazuje jej pustą tablicę, a nie null, więc numbers.length wynosi 0, a pętla nic nie robi. Dla przypadku bez argumentów nie potrzebujesz sprawdzania null:

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

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

Po drugie, przekazanie dosłownego null jest niejednoznaczne i niebezpieczne: Java może zinterpretować count(null) jako "cała tablica varargs jest null", a nie "jeden element null", co potem rzuca NullPointerException, gdy odczytujesz jej length. Jeśli naprawdę chodzi ci o jeden element null, zapisz to wprost: count((Object) null).

Dalej: klasy

Varargs dopełniają to, co możesz zrobić z parametrami metod: elastyczne listy argumentów obok przeciążania. Do tej pory metody żyły luźno w klasie ze static. Dalej zobaczysz, jak naprawdę działają klasy: łączenie danych (pól) i zachowania (metod) we własne typy, co jest sercem programowania obiektowego w Javie.