Java one or more arguments

Tech Tutorials

Tutorials and posts about Java, Spring, Hadoop and many more. Java code examples and interview questions. Spring code examples.

Thursday, March 25, 2021

Varargs (Variable-length Arguments) in Java

varargs in Java short for variable-length arguments is a feature that allows the method to accept variable number of arguments (zero or more). With varargs it has become simple to create methods that need to take a variable number of arguments. The feature of variable argument (varargs) has been added in Java 5.

Syntax of varargs

A vararg in Java is specified by three ellipsis (three dots) after the data type, its general form is

return_type method_name(data_type . variableName)

Need for varargs in Java

Prior to Java 5, in case there was a need of variable number of arguments, there were two ways to handle it

• If the max number of arguments, a method can take was small and known, then overloaded versions of the method could be created.
• If the maximum number of arguments a method could take was large or/and unknown then the approach was to put those arguments in an array and pass them to a method which takes array as a parameter.

• The addition of new argument may result in writing a new overloaded method.
• Constructing an array of parameters every time makes it difficult to maintain.

• Offers a much simpler option to have a method with variable number of arguments.
• Gets the work done with less code as no need to write overloaded methods.

Java varargs Example

public class VarargsExample < public void displayData(String . values)< System.out.println("Number of arguments passed " + values.length); for(String s : values)< System.out.println(s + " "); >> public static void main(String[] args) < VarargsExample vObj = new VarargsExample(); // four args vObj.displayData("var", "args", "are", "passed"); //three args vObj.displayData("Three", "args", "passed"); // no-arg vObj.displayData(); >>

Number of arguments passed 4 var args are passed Number of arguments passed 3 Three args passed Number of arguments passed 0

In the example program displayData() method is called with different number of argument, first call with four arguments, then three arguments and then with zero arguments. All these calls are handled by the same method which takes varargs.

How does Java varargs work

When a method with variable number of arguments is called, Java compiler matches the argument from left to right, if there are any «normal» parameter then those are passed as it is, when the varargs parameter (which has to be the last parameter) is reached the remaining parameters are stored in an array which is referred by the name given to varargs and data type of the array is same as the data type of the varargs field.

From the above example you can see that length is used to find the number of arguments passed to the method. It is possible because arguments to the varargs are implicitly passed as an array.

Restriction with varargs in Java

1. It is possible to have other parameters with varargs parameter in a method, however in that case, varargs parameter must be the last parameter declared by the method.

void displayValues(int a, int b, int … values) // OK void displayValues(int a, int b, int … values, int c) // compiler error

void displayValues(int a, int b, int … values, int … moreValues) // Compiler error

Overloading varargs Methods in Java

Overloading varargs method example

public class OverloadingVarargsExp < // Method which has string vararg parameter public void displayData(String . values)< System.out.println("Number of arguments passed " + values.length); for(String s : values)< System.out.println(s + " "); >> // Method which has int vararg parameter public void displayData(int . values) < System.out.println("Number of arguments passed " + values.length); for(int i : values)< System.out.println(i + " "); >> // Method with int vararg and one more string parameter public void displayData(String a, int . values) < System.out.println(" a " + a); System.out.println("Number of arguments passed " + values.length); for(int i : values)< System.out.println(i + " "); >> public static void main(String[] args) < OverloadingVarargsExp vObj = new OverloadingVarargsExp(); // four string args vObj.displayData("var", "args", "are", "passed"); // two int args vObj.displayData(10, 20); // One String param and two int args vObj.displayData("Test", 20, 30); >>

Number of arguments passed 4 var args are passed Number of arguments passed 2 10 20 a Test Number of arguments passed 2 20 30

Java varargs and overloading ambiguity

In some cases call may be ambiguous while we have overloaded varargs method in Java. Let’s see an example.

public class OverloadingVarargsExp < // Method which has string vararg parameter public void displayData(String . values)< System.out.println("Number of arguments passed " + values.length); for(String s : values)< System.out.println(s + " "); >> // Method which has int vararg parameter public void displayData(int . values) < System.out.println("Number of arguments passed " + values.length); for(int i : values)< System.out.println(i + " "); >> public static void main(String[] args) < OverloadingVarargsExp vObj = new OverloadingVarargsExp(); // four string args vObj.displayData("var", "args", "are", "passed"); // two int args vObj.displayData(10, 20); // This call is ambiguous vObj.displayData(); >>

In this program when we make a call to displayData() method without any parameter it throws error, because compiler is not sure whether this method call is for displayData(String . values) or displayData(int . values)

Same way if we have overloaded methods where one has the vararg method of one type and another method has one parameter and vararg parameter of the same type, then also we have the ambiguity-

displayData(int . values) And displayData(int a, int . values)

These two overloaded methods will always have ambiguity.

• With Varargs in Java is has become simple to create methods that need to take a variable number of arguments.
• In a vararg method call, arguments are inherently passed as an array itself.
• If there are other parameters, then varargs parameter should be the last one.
• In a method there can be only one varargs parameter.
• vararg methods can be overloaded.
• With overloaded vararg methods there may be ambiguity, in case method is called with no parameter at all.
• With varargs it is possible to write the main method as public static void main(String . args).

That’s all for this topic Varargs (Variable-length Arguments) in Java. If you have any doubt or any suggestions to make please drop a comment. Thanks!

Источник

How to implement a constructor reference with one or more arguments in Java?

A method reference can also be applicable to constructors in Java 8. A constructor reference can be created using the class name and a new keyword. The constructor reference can be assigned to any functional interface reference that defines a method compatible with the constructor.

Syntax

Example of Constructor Reference with One Argument

import java.util.function.*; @FunctionalInterface interface MyFunctionalInterface < Student getStudent(String name); >public class ConstructorReferenceTest1 < public static void main(String[] args) < MyFunctionalInterface mf = Student::new; Functionf1 = Student::new; // Constructor Reference Function f2 = (name) -> new Student(name); System.out.println(mf.getStudent("Adithya").getName()); System.out.println(f1.apply("Jai").getName()); System.out.println(f2.apply("Jai").getName()); > > // Student class class Student < private String name; public Student(String name) < this.name = name; >public String getName() < return name; >public void setName(String name) < this.name = name; >>

Output

Example of Constructor Reference with Two Arguments

import java.util.function.*; @FunctionalInterface interface MyFunctionalInterface < Student getStudent(int id, String name); >public class ConstructorReferenceTest2 < public static void main(String[] args) < MyFunctionalInterface mf = Student::new; // Constructor Reference BiFunctionf1 = Student::new; BiFunction f2 = (id, name) -> new Student(id,name); System.out.println(mf.getStudent(101, "Adithya").getId()); System.out.println(f1.apply(111, "Jai").getId()); System.out.println(f2.apply(121, "Jai").getId()); > > // Student class class Student < private int id; private String name; public Student(int id, String name) < this.id = id; this.name = name; >public int getId() < return id; >public void setId(int id) < this.id = id; >public String getName() < return name; >public void setName(String name) < this.name = name; >>

Источник

Java varargs

Сегодня мы обсудим такую штуку как varargs в Java. Varargs — или Variable Arguments — это технология, которая позволяет создавать методы с произвольным количеством аргументов. В данной статье мы научимся создавать такие методы, обсудим, зачем нужны varargs и когда их лучше использовать.

Что такое varargs?

Varargs — это аргументы переменной длины: фича, которая появилась еще в JDK5. Varargs позволяют нам создавать методы с произвольным количеством аргументов. По большому счету, создавать такие методы можно было и раньше. Правда, делать это было не очень удобно. Приведем пример. Допустим, нам необходимо написать метод, который будет принимать произвольное количество целочисленных аргументов и складывать их вместе. У нас есть два варианта. Вариант 1 — перегрузка:

 class Calculator < int sum(int a, int b); int sum(int a, int b, int c); int sum(int a, int b, int c, int d); int sum(int a, int b, int c, int d, int e); > 

Но с перегрузкой возникают две проблемы. Во-первых, не всегда понятно, когда пора остановиться, а во-вторых, это громоздко. Лучше уж массивы. Вариант 2 — массивы:

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

 public static void main(String. sss)

Согласны, можно, конечно, и короче все записать. Но во-первых, хочется все-таки продемонстрировать неудобство использования массивов в качестве аргументов переменной длины, а во-вторых, даже если мы запишем так:

 int[] arguments = ; int sum = calculator.sum(arguments); 

То мы все равно не избавимся излишнего количества кода. Однако с выходом Java 5 для решения этих проблем появилась фича Varargs. Она позволила передавать в методы произвольное количество аргументов. Выглядит это примерно так:

 public class Calculator < public static void main(String. sss) < Calculator calculator = new Calculator(); int sum = calculator.sum(1,10,123,234,6234,12,8); >int sum(int. numbers) < return Arrays.stream(numbers).sum(); >> 

Итак, резюмируем. Varargs — это аргументы переменной длины, фича, которая появилась с выходом Java 5. Далее более подробно рассмотрим некоторые правила работы с Varargs.

5 правил varargs

Правило 1. Vararg аргумент (или же аргумент переменной/произвольной длины) обозначается через троеточие следующим образом:

 String. words Integer. numbers Person. people Cat. cats 

 void print(String. words) int sum(Integer. numbers) void save(Person. people) void feed(Cat. cats) 

 void print(String. words, String anotherWord) // - Так нельзя! void print(String. words, int someNumber) // - Так нельзя! void print(String anotherWord, String. words) // - Так можно void print(int someNumber, String. words) // - Так можно 

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

 public class Main < public static void main(String. sss) < print("Как","же","прекрасно","изучать","Java"); >static void print(String. words) < for (int i = 0; i < words.length; i++) < System.out.println(words[i]); >> > 

Примеры varargs

В примере ниже мы напишем метод, который принимает varargs состоящий из целых чисел и выводит на экран количество переданных элементов и их сумму. Передадим в этот метод и массив, и ряд целых чисел (оба варианта допустимы):

 public static void main(String. sss) < int[] a = new int[100]; for (int i = 0; i < a.length; i++) < a[i] = i; >sum(a); sum(1,2,3,4,5,6,7,8,9,10); > static void sum(int. numbers)

 Кол-во элементов для сложения - 100, сумма - 4950 Кол-во элементов для сложения - 10, сумма - 55 

Стоит сказать, что метод System.out.printf также принимает varargs. Если мы взглянем на код этого метода, то убедимся в этом:

 public PrintStream printf(String format, Object . args)

 public static String format(String format, Object. args)

Когда использовать varargs?

Ответ на этот вопрос зависит от того, кто спрашивает. Если подобный вопрос задает клиент некоторого API, в котором есть методы с varargs, то ответ будет “использовать такие методы как можно чаще”. Для клиента кода varargs существенно упрощает жизнь, облегчая написание кода и повышая его читаемость. Однако в случае, если данный вопрос задает разработчик API, который интересуется, как часто стоит создавать методы с varargs, то ответ будет “не следует часто использовать varargs”. Varargs следует использовать только тогда, когда выгода от его использования очевидна. Также не следует перегружать методы с varargs, так как это вызовет у клиентов вашего кода затруднения в понимании, какой из перегруженных методов в действительности вызывается.

Заключение

• Написать void метод, который принимает ряд целых чисел и возвращает их среднее арифметическое.
• Написать void метод, который принимает ряд строк и выводит на печать самое длинное слово.
• Написать метод, который возвращает boolean и принимает первым аргументом переменную типа String , а следующим аргументом ряд boolean , переменной длины.
  Возможные значения String — AND , OR , XOR . В случае, если первый аргумент имеет какое то другое значение, метод должен бросить исключение IllegalArgumentException .
  Метод должен осуществить логическую операцию (указанную в первом аргументе ) над каждым элементом varargs аргумента и вернуть результат вычисления.

• «AND», true, true, false — вернет false
• «OR», false, true, false, false — вернет true

Источник