Varargs java что это

Варарги на Яве

Переменные были введены в Java 5 и обеспечивают сокращение для методов, поддерживающих произвольное количество параметров одного типа.

В этой статье мы увидим, как мы можем использовать эту основную функцию Java.

2. Перед Вараргами ​

До Java 5 всякий раз, когда мы хотели передать произвольное количество аргументов, нам приходилось передавать все аргументы массивом или реализовывать N методов (по одному на каждый дополнительный параметр):

 public String format()  ... >    public String format(String value)  ... >    public String format(String val1, String val2)  ... > 

3. Использование Вараргов ​

Переменные аргументы помогают нам избежать написания стандартного кода, вводя новый синтаксис, который может автоматически обрабатывать произвольное количество параметров — используя массив под капотом.

Мы можем определить их, используя объявление стандартного типа, за которым следует многоточие:

 public String formatWithVarArgs(String... values)    // .   > 

И теперь мы можем вызвать наш метод с произвольным количеством аргументов, например:

 formatWithVarArgs();    formatWithVarArgs("a", "b", "c", "d"); 

Как упоминалось ранее, varargs — это массивы, поэтому нам нужно работать с ними так же, как с обычным массивом.

4. Правила​

Варарги просты в использовании. Но есть несколько правил, которые мы должны помнить:

• Каждый метод может иметь только один параметр varargs.
• Аргумент varargs должен быть последним параметром

5. Загрязнение кучи​

Использование varargs может привести к так называемому загрязнению кучи . Чтобы лучше понять загрязнение кучи, рассмотрим этот метод varargs :

 static String firstOfFirst(ListString>... strings)    ListInteger> ints = Collections.singletonList(42);   Object[] objects = strings;   objects[0] = ints; // Heap pollution    return strings[0].get(0); // ClassCastException   > 

Если мы вызовем этот странный метод в тесте:

 String one = firstOfFirst(Arrays.asList("one", "two"), Collections.emptyList());    assertEquals("one", one); 

Мы получили бы исключение ClassCastException , даже если бы здесь не использовались явные приведения типов:

 java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String 

5.1. Безопасное использование​

Каждый раз, когда мы используем varargs , компилятор Java создает массив для хранения заданных параметров. В этом случае компилятор создает массив с компонентами универсального типа для хранения аргументов.

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

warning: [varargs] Possible heap pollution from parameterized vararg type T 

Использование varargs безопасно тогда и только тогда, когда:

• Мы ничего не сохраняем в неявно созданном массиве. В этом примере мы сохранили List в этом массиве .
• Мы не позволяем ссылке на сгенерированный массив избежать выхода из метода (подробнее об этом позже)

Если мы уверены, что сам метод безопасно использует varargs, мы можем использовать @SafeVarargs для подавления предупреждения.

Проще говоря, использование varargs безопасно, если мы используем их для передачи переменного количества аргументов от вызывающей стороны к методу и ничего больше!

5.2. Справочник по побегу от вараргов​

Давайте рассмотрим еще одно небезопасное использование varargs :

 static T> T[] toArray(T... arguments)    return arguments;   > 

Сначала может показаться, что метод toArray совершенно безобиден. Однако, поскольку массив varargs передается вызывающей стороне, это нарушает второе правило безопасного использования varargs .

Чтобы увидеть, насколько этот метод может быть опасным, давайте используем его в другом методе:

 static T> T[] returnAsIs(T a, T b)    return toArray(a, b);   > 

Затем, если мы вызовем этот метод:

 String[] args = returnAsIs("One", "Two"); 

Мы снова получили бы ClassCastException. Вот что происходит, когда мы вызываем метод returnAsIs :

• Чтобы передать a и b методу toArray , Java должен создать массив
• Поскольку Object[] может содержать элементы любого типа, компилятор создает один
• Метод toArray возвращает заданный Object[] вызывающей стороне.
• Поскольку сайт вызова ожидает String[], компилятор пытается привести Object[] к ожидаемому String[] , следовательно, ClassCastException

Для более подробного обсуждения загрязнения кучи настоятельно рекомендуется прочитать пункт 32 книги Effective Java Джошуа Блоха .

6. Заключение​

Варарги могут убрать много шаблонов в Java.

И, благодаря их неявному автоупаковыванию в Array и из него, они играют роль в обеспечении безопасности нашего кода в будущем.

Как всегда, все примеры кода из этой статьи могут быть доступны в нашем репозитории GitHub .

Varargs java что это

В первой части руководства мы подробно рассмотрели одномерные массивы и операции, применимые к ним. В данной же статье разбирается такая тема, как varargs.

1. Varargs

Varargs (Variable Arguments List, изменяющийся список аргументов) — это способ создания методов, которые могут принимать произвольное количество аргументов одного типа (от нуля и более). Данная возможность появилась в JDK 5.

В книге «Java. Эффективное программирование» Джошуа Блох пишет: «Использование переменного количества аргументов было разработано для метода printf и рефлексии». Также он называет varargs-методы, как variable arity, т. е. методы с переменной арностью (термин из математики, означающий количество передаваемых аргументов).

Давайте на примере printf и разберем данную функцию языка.

Метод printf (аналог одноименного метода из языка C), как и методы print и println, предназначен для вывода сообщений в консоль, но, в отличие от последних, позволяет применять к ним форматирование. Реализации данных методов находятся в пакете java.io в классе PrintStream, но их мы знаем как методы, вызываемые в конструкции System.out.*

Приведем пример реализации printf:

 public PrintStream printf(String format, Object. args)

Данный метод принимает следующие аргументы:

• String format — выводимое на консоль сообщение, включающее параметры форматирования (дескрипторы)
• Object… args — произвольное количество значений форматируемых переменных

В целом, можно сказать, что инструкции из String format применяются для форматирования аргументов Object… args.

Запись вида Object… args и есть varargs. Существуют, конечно, и другие способы написания: Object …args или даже Object … args, но они не распространены, и их использовать не стоит. При этом три точки после типа указывают, что метод в качестве аргумента может принимать как массив, так и любую последовательность аргументов, записанных через запятую, которая все равно преобразуется в одномерный массив.

Пусть имеется следующий метод:

 public void foo(int. args) <> 

Мы его вызываем так:

 foo(10, 20); 

«Под капотом» компилятор на уровне байт-кода неявно заменяет переданную последовательность массивом. По смыслу это равносильно следующей записи:

 foo(new int[]); 

Varargs работает следующим образом: без участия программиста создается массив, размер которого определяется числом передаваемых аргументов, инициализируется ими, а затем передается в метод. Уже в методе аргумент varargs используется как одномерный массив.

Вернемся к методу printf и приведем пример его применения:

 System.out.printf("Hello"); System.out.printf("Player %s attempts: ", player.getName()); System.out.printf("%5s %5s %n", "Dec", "Char"); System.out.printf("Число %,d содержит %d %s количество единиц%n", a, b, c); 

Как видно из примера, printf может принимать разное количество аргументов: в нашем случае от одного до четырех. Такая гибкость как раз и обеспечивается за счет конструкции Object… args (тип ожидаемых аргументов может быть любым, не обязательно Object).

Реализовать такую универсальность до введения varargs было возможно двумя способами:

1. Использовать массив в качестве контейнера для передачи в метод разного количества аргументов (зачастую это громоздко):

 char[] arr = new char[4]; arr[0] = 'J'; arr[1] = 'a'; arr[2] = 'v'; arr[3] = 'a'; print(arr); void print(char[] arr) < // какой-то код >

можно, конечно, чуть короче:

 char[] arr = ; print(arr); 

Или даже так:

 print(new char[]); 

Но это не всегда бывает возможно.

2. Реализовать множество перегруженных методов, принимающих различное число аргументов (что не самая плохая идея, в пределах разумного, в чем мы убедимся далее). Но это сильно засоряет класс, приводя программистов в недоумение от большого числа почти одинаковых методов, да и не всегда понятно, какое количество перегруженных методов нужно реализовать и когда стоит остановиться

В качестве примера можно привести метод для передачи игроков в какую-то игру:

 void start(Player p1) <> void start(Player p1, Player p2) <> void start(Player p1, Player p2, Player p3) <> void start(Player p1, Player p2, Player p3, Player p4) <> 

Как альтернатива подобной многословности как раз и был предложен varargs.

Разработчики Java посчитали, что нужно предоставить возможность создавать методы с заранее неизвестным числом аргументов без использования массивов, делегировав эту задачу компилятору. Подобные упрощения в языках программирования обычно называются синтаксическим сахаром.

Целью создания таких фич, как varargs, является:

• упрощение кода
• уменьшение многословности языка
• облегчение работы программиста
• удобство

Разберем еще один пример.

Пусть необходимо реализовать метод, который принимает последовательность аргументов типа String и отображает их в консоли. Для демонстрации воспользуемся методом main, используя в качестве принимаемого аргумента varargs. При этом следует отметить, что String[] и String… являются синонимами.

 public class VarargsTest < public static void main(String. args) < System.out.println("Длина массива (количество аргументов) = " + args.length); for (String str : args) < System.out.print(str + " "); >> > 

Запустим в консоли программу, введя любой текст после названия класса:

 > java VarargsTest.java My name is Max! Длина массива (количество аргументов) = 4 My name is Max! 

Стоит отметить, что если запустить программу без указания дополнительных аргументов, то массив все равно будет создан и передан в метод, при этом его размер будет равен 0. Попробуйте самостоятельно в этом убедиться.

В качестве ограничения любой метод может использовать varargs только в единственном числе и строго последним аргументом.

Приведем примеры неправильного использования varargs:

 1. public void foo1(int. nums, String values) <> 2. public void foo2(String. values, int. nums) <> 3. public void foo3(String[] values, . int nums) <> 

Ни один из вариантов не скомпилируется потому, что:

1. varargs не является последним
2. два varargs не допускаются в одном методе
3. … необходимо размещать после типа, а не до него

И еще один пример:

 public int howMany(boolean b, boolean. b2)

Варианты вызова метода:

 A. howMany(); B. howMany(true); C. howMany(true, true); D. howMany(true, true, true); E. howMany(true, ); F. howMany(true, new boolean[2]); 

• Вариант A не cкомпилируется, потому что в методе не передается хотя бы начальный параметр (boolean b). Тут действует то правило, когда varargs может быть равен 0, но все остальные аргументы обязательно должны быть переданы
• Вариант B и C правильные, т. к. первый вызов соответствует правилу из предыдущего пункта, а во втором создается массив размером 1
• Варианты D и F правильные, т. к. передают нужное количество аргументов: начальный и еще два для преобразования в массив varargs размером 2
• Вариант E не скомпилируется, потому что неверно объявляется массив: должно быть new boolean[]
• Вариант F верный, т. к. передает начальный параметр и массив размером 2 (массивы и varargs являются синонимами)

 of() of(E e1) of(E e1, E e2) of(E e1, E e2, E e3) of(E e1, E e2, E e3, E e4) of(E e1, E e2, E e3, E e4, E e5) of(E e1, E e2, E e3, E e4, E e5, E e6) of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) of(E. elements) 

 public static boolean someFields(String s, boolean. b) < if (s.equals("AND")) < for (boolean bo : b) < if (!bo) < return false; >> return true; > else if (s.equals("OR")) < for (boolean bo : b) < if (bo) < return true; >> > else throw new IllegalArgumentException(); return false; >