Introduction to Java varargs
The Java varargs is a Java Programming Language concept that simplifies the concept of creating the methods that are actually needed to take some variable number of arguments. This feature/concept is called as varargs, and varargs is the short name for the variable-length arguments. Here a method that will take some variable number of the arguments is a varargs method. Prior to the JDK 5 version, varargs(variable-length arguments) can be used to handle in two ways. One way is by using the overloaded method and the second way is by putting the arguments into an array, and this passing array to the method is done.
Syntax
Public static void fun(int …a1)
{
//method body1
}
Explanation: Here, the fun() function is created with the parameter “int …a1”. Then the method body will be entered to use at the time of execution. One should use only one variable arg-arguments in the specific method. The vararg – variable-length argument must be the last argument; if not, compile might occur.
How does varargs works in Java?
The varargs (Variable Length Arguments) of the Java Programming Language will help simplify the creation of methods that actually take a variable number of arguments. A Java method that takes a variable number of args-arguments is called a varargs method. It is in the JDK5 version. Prior to the JDK 5 version/versions, variable-length args-arguments will handle in two ways. The first method is with the help of the overloaded method, and another way is putting args-arguments into a specific array, and then this array will be passed to the specific method. Most of the time, both are somewhat potentially error-prone, and it is going to require more and more code. The varargs concept works by allowing the method which actually accepts multiple arguments or none.
The “…” syntax will work by telling the compiler that varargs is used with these args-arguments that they should be stored in a specific array which is referred to by a1.
The vararg-variable arguments/Variable-Length Arguments methods may overload, but the overloading leads to the specific ambiguity. From the prior JDK 5 versions, varargs- Variable Length Arguments can be or can also handled in two types of ways. The first way is by overloading, and the second way is by using the array arg-argument. There will be only one type of variable argument in a method. The varargs(Variable arguments) will be or must the last argument.
There are Erroneous varargs too. One is by specifying the two varargs in only one single method. The second is by specifying the method’s first parameter instead of the last parameter.
4.8 (8,902 ratings)
View Course
The method can have a variable’s length parameter with some other different parameters too, but one has to ensure that only one vararg parameter should exist, and it should be written in the parameter the last section of the method declaration.
Examples to Implement Java varargs
Below are some examples mentioned:
Example #1
This is the implementation of varargs using Java Programming Language. At first, a class “Test11” is created, and then fun1() is created with varargs syntax. Then system.out.the print() function is used with the length calculating syntax “a1.length”, which is nothing but the number of elements of the array calculation. Then FOR-EACH loop is created to know each and every element of a particular array. Then system.out.the print() function is used just to print the elements of each array. Then system.out.println() is used just for the line break in the output of the command prompt. Then “Public static void main(String args[])” is created to mention the array elements inside of the specific function “fun1()”. Three different types of array elements which are with different length. Check out the output in the output section below.
Code:
class Test11
{
static void fun1(int ...a1)
{
System.out.println("The Number of the arguments metioned: " + a1.length);
for (int i1: a1)
System.out.print(i1 + " ");
System.out.println();
}
public static void main(String args[])
{
fun1(1000);
fun1(11, 12, 13, 14);
fun1();
}
}
Output:
Example #2
This is the example of a Java Program with the varargs concept implementation with just normal arguments. Here at first, a class “Test21” is created with a new function “, fun21” with two different types of arguments/parameters. Inside of the fun21() function, system.out.print() is created 2 times. The first creation is to print the str2 value, and then the second creation is to print the length of the array. Then the for-each loop is created to extract the elements of an array with different types and different numbers of elements. With the FOR loop’s help, only the numerical arguments/values will be printed, and the string elements will be printed differently.
Code:
class Test21
{
static void fun21(String str2, int ...a2)
{
System.out.println("String: " + str2);
System.out.println("Number of arguments is: "+ a2.length);
for (int i2: a2)
System.out.print(i2 + " ");
System.out.println();
}
public static void main(String args[])
{
fun21("PavanKumarSakeCEOofProfitLoops", 1000, 2000);
fun21("ProfitLoops", 21, 22, 23, 24, 25);
fun21("fortheWorld");
}
}
Output:
Example #3
This is an example of implementing a varargs program in Java code. Here at first, Test 21 class is created, then the display () static function is created. Then inside of it, system.out.println() is used to print the string element. Then the for-each concept is used to print all the elements of the array. Then the parenthesis closing is done for the function display(). Then “public static void main(String_args[])” is used for entering the code, which actually returns the output. Then the display() is used with different types of array elements with different lengths.
Code:
class Test21{
static void display(String... values1){
System.out.println("Here Now the display method is invoked ");
for(String s1:values1){
System.out.println(s1);
}
}
public static void main(String args[]){
display();
display("Howdyhello");
display("my","name","is","varargs-pavan");
display("Pavan Kumar Sake is the future billionaire. Soon You will see.. :-)");
}
}
Output:
Conclusion
I hope you learned the actual definition of Java varargs (Variable Length Arguments) along with their syntax and explanation, How the varargs works in the Java Programming Language, and the various examples of implementing the varargs concept to understand better.
Recommended Articles
This is a guide to Java varargs. Here we discuss an introduction to Java varargs with appropriate syntax, how does it work and respective examples. You can also go through our other related articles to learn more –
