Varargs в Java: методы, принимающие любое число аргументов

Один метод, любое число аргументов

Иногда вы заранее не знаете, сколько аргументов понадобится методу. В один момент вам нужно max(3, 9), в следующий — max(1, 7, 4, 2, 8). Без varargs пришлось бы писать перегрузку под каждое число аргументов или заставлять вызывающий код строить массив. Varargs — сокращение от variable arguments (переменные аргументы) — позволяют одному методу принимать ноль, один или много значений одного типа.

Их объявляют, поставив три точки (...) после типа параметра:

public class Main {
    static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) {   // numbers — это просто 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 - ноль аргументов разрешён
        System.out.println(sum(4, 8, 15, 16));   // 43
    }
}

Вызывающий код передаёт разрозненные значения; внутри метода numbers — настоящий массив. В этом вся суть: компилятор упаковывает аргументы в массив за вас.

Varargs — это просто массив

Во время выполнения никакой магии нет. Параметр, объявленный как int... numbers, внутри метода — это в точности int[]. Вы можете узнать его length, обращаться по индексу и перебирать его, как любой другой массив.

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

Поскольку это по-настоящему массив, методу с varargs можно передать и уже имеющийся у вас массив — он принимает обе формы:

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));        // передаём существующий массив
        System.out.println(sum(1, 2, 3, 4));  // или разрозненные значения
    }
}

Правила: последний и только один

Два правила исключают неоднозначность varargs, и компилятор соблюдает оба:

1. Параметр varargs должен быть последним. Сначала идут обычные параметры, затем параметр ... вбирает всё, что осталось.
2. У метода может быть не более одного параметра varargs. Два сделали бы невозможным понять, где заканчивается один и начинается следующий.

public class Main {
    // OK: сначала обычный параметр, varargs в конце
    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");   // часть с varargs может быть пустой
    }
}

Это компилируется. Но поставить varargs первым — static void log(Object... values, String level) — ошибка компиляции: varargs parameter must be the last. Обязательный параметр level всегда предшествует ....

Где вы уже используете varargs

Вы вызывали методы с varargs всё это время. System.out.printf и String.format — классические примеры: их второй параметр — 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(...) и многие API в стиле билдеров тоже используют varargs. Именно поэтому им можно передать любое число элементов, не оборачивая ничего в массив самостоятельно.

Varargs и перегрузка

Varargs и перегрузка взаимодействуют одним неожиданным образом. Когда обычная перегрузка и перегрузка с varargs обе могли бы подойти к вызову, Java предпочитает более конкретную — побеждает метод с фиксированным числом аргументов:

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 (более конкретная)
        System.out.println(pick(1, 2, 3));   // varargs version
        System.out.println(pick());          // varargs version
    }
}

pick(1, 2) подходит обеим, но Java выбирает перегрузку без varargs, потому что она ближе по соответствию. Метод с varargs срабатывает только тогда, когда не подходит ни одна перегрузка с фиксированным числом аргументов. Обычно это именно то, что нужно, но это означает, что добавление перегрузки с varargs может незаметно изменить, к какому методу разрешается вызов.

Следите за пустыми и null-вызовами

Два подвоха ловят людей. Первый: вызов метода с varargs без аргументов передаёт методу пустой массив, а не null — поэтому numbers.length равно 0, и цикл ничего не делает. Проверка на null для случая без аргументов не нужна:

public class Main {
    static int count(Object... items) {
        return items.length;   // 0 для count(), никогда не NPE
    }

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

Второй: передача буквального null неоднозначна и опасна: Java может истолковать count(null) как «весь массив varargs равен null», а не «один элемент null», что затем приведёт к NullPointerException при чтении его length. Если вы действительно имеете в виду единственный элемент null, укажите это явно: count((Object) null).

Далее: классы

Varargs завершают то, что можно делать с параметрами методов, — гибкие списки аргументов поверх перегрузки. До сих пор методы свободно жили в классе с static. Дальше вы увидите, как на самом деле работают классы: объединение данных (полей) и поведения (методов) в собственные типы — это сердце объектно-ориентированной Java.