varArgs Example to calculate sum of numbers (calling same method independent of number of input parameters)

exercise 6.14 jhtp: (variable length argument list)
java varargs
usage of varargs does away with the concept of
java override variable arguments
java multiple args
java object... args
overloading varargs method in java
varargs array java

try comething like this

public int sum(int... args) {  
  int sum = 0;  
  for (int i : args)  
    sum += i;  
  return sum;  
}

then you can call

sum(3);
sum(3, 4, 5);
sum(3, 4, 5, 6, 7);

erit: amit was 5 sec quicker :)

Is there an easier way to sum up the total of an array than to pass , varArgs Example to calculate sum of numbers (calling same method independent of number of input parameters) [duplicate] (4 answers). The number of arguments can be found out using a.length, the way we find the length of an array in Java. Note: A method can have variable length parameters with other parameters too, but one should ensure that there exists only one varargs parameter that should be written last in the parameter list of the method declaration.


Try this :

public class Main
{
    public static void main(String[] argv)
    {
        int result1 = sum(1, 2);
        int result2 = sum(1, 2, 3);
        int result3 = sum(1, 2, 4, 5, 6, 1000);

        System.out.println(result1 + "\n" + result2 + "\n" + result3);
    }

    private static int sum(int... args)
    {
        int ret = 0;

        if (args != null)
        {
            for (int val : args)
            {
                ret += val;
            }
        }
        return ret;
    }
}

Variable Arguments (Varargs) in Java, The number of arguments can be found out using a.length, the way we find the length of an array in Java. Note: A method can have variable length parameters  You can expand the above and create a function that will use double as data type and calculate the sum. After that, create a function that will calculate average value and sum of unknown number of numbers. Then, you might create your: and, or, xor, nor etc… functions. This group of functions could be useful in Calc, for example.


Quick approach

This could be a solution (note: always use meaningful variable names!):

private static int sum(int i, int... others) {
    int sum = i;

    if(others!=null)
        for(int other : others) {
            sum+=other;
        }
    }
    System.out.println("sum:" + sum);
    return sum;
}

Notice the arguments. As it is not very meaningful to sum 1 number, this construct ensures that there is at least 1 int coming in. And this one also checks for null value in the vararg.

Overflowing with emotions...

What would happen with the quick approach when executing this:

int veryBigNumber = sum(Integer.MAX_VALUE, 1);

veryBigNumber would in fact be ==Integer.MIN_VALUE...

This might be a problem. As Java does not throw an exception when an overflow occurs, you could end up with incorrect results. You could do a check for overflows:

private static int aLittleBitSaferSum(int i, int... others) throws ArithmeticException {
    int sum = i;
    if(others!=null)
        for(int other : others) {
            if(Integer.MAX_VALUE-other<sum) {
                throw new ArithmeticException("Sum would be too large to fit in int");
            }         
            if(Integer.MIN_VALUE+other>sum) {
                throw new ArithmeticException("Sum would be too small to fit in int");
            }         
            sum+=other;
        }
    }
    System.out.println("sum: " + sum);
    return sum;
}

Of course, this is just a dumb check... The result could fit very well in an int, for example with this:

sum(Integer.MAX_VALUE, 1, -1);

Which should result in Integer.MAX_VALUE - which it would wihtout the checks.

Extending the horizon

Fear not! The aforementioned problem could also be solved. For example, by providing a clever algorithm ordering the operands in a way that the partial result would always fit in the int range, but I think that is a problem not trivial to be solved... And would cost a lot in computing power.

However, by extending the range of the values the function is dealing with, it can do a lot better:

private static int aLittleBitSaferSum(int i, int... others) throws ArithmeticException {
    long sum = i;
    if(others!=null)
        for(int other : others) {
            if(Long.MAX_VALUE-other<sum) {
                throw new ArithmeticException("Sum would be too large for this algorithm to deal with");
            }         
            if(Long.MIN_VALUE+other>sum) {
                throw new ArithmeticException("Sum would be too small for this algorithm to deal with");
            }         
            sum+=other;
        }
    }

    if(Integer.MAX_VALUE<sum) {
        throw new ArithmeticException("Sum would be too large to fit in int");
    }         
    if(Integer.MIN_VALUE>sum) {
        throw new ArithmeticException("Sum would be too small to fit in int");
    }       

    System.out.println("sum: " + sum);
    return (int)sum;
}

This still has limitations, as long has too, but as long is twice the size of an Integer, it is far less likely to cause a problem. This is however a bit slower due to the extra work involved, also a lot less readable because of the checks.

I want it all

... and I want it now. The range can still be a problem, this is a solution to it:

private static int aSafeButSlowerSum(int i, int... others) throws ArithmeticException {
    BigInteger sum = BigInteger.valueOf(i);
    BigInteger intMax = BigInteger.valueOf(Integer.MAX_VALUE); //should be a private static final class variable
    BigInteger intMin = BigInteger.valueOf(Integer.MIN_VALUE); //should be a private static final class variable

    if(others!=null)
        for(int other : others) {
            sum=sum.add(BigInteger.valueOf(i));
        }
    }

    if(intMax.compareTo(sum)<0) {
        throw new ArithmeticException("Sum would be too large to fit in int");
    }         
    if(intMin.compareTo(sum)>0) {
        throw new ArithmeticException("Sum would be too small to fit in int");
    }       

    System.out.println("sum: " + sum.toString());
    return sum.intValue;
}

This is even slower due to all the BigInteger stuff, but shows no problems of the above functions. (so it will be a little bit less "now" as with the other options, but there is a price to pay for the extras..)

How to pass multiple arguments to function ?, The final expression uses calljava function to call the java.lang.math method directly. The middle flow (input stream VarArgsIsIn) uses the custom function IsIn the custom function SumAll in that same class to compute the sum of any number To keep the example simple, the custom functions do not validate their inputs  Java Integer sum() Method. The sum() method of Java Integer class numerically returns the sum of its arguments specified by a user. This method adds two integers together as per the + operator. It can be overloaded and accepts the arguments in int, double, float and long.


public static void main(String[] arg) {
    int result2 = sumVarArgs(1, 2);
    System.out.println(result2);
    int result3 = sumVarArgs(1, 2, 3);
    System.out.println(result3);
    int result4 = sumVarArgs(1, 2, 3, 4);
    System.out.println(result4);
    int result5 = sumVarArgs(1, 2, 3, 4, 5);
    System.out.println(result5);

}


    /**
     * Aoccepts an all int variables and conciders them as an array and adds
     * them
     *
     * @param argsAry multiple number of input parameters having data type
     * <i>int</i>
     * @return sum of all passed int variables in int format
     */
public static int sumVarArgs(int... argsAry) {
     int c = 0;
     for (int i = 0; i < argsAry.length; i++) {
         c += argsAry[i];
     }
     return c;
}

Java Varargs, Create a function which takes in a variable number of arguments and Also show, if possible in your language, how to call the function on a An array of parameters with a count as parameter zero can be used in The C++ varargs are basically the same as in C (therefore you can This sum is constant. The redplot function accepts a variable-length input argument list and returns a variable-length output argument list. It sets the line color to red, and forwards other input values to the plot function. This function wrapper enables you to pass redplot the same inputs as plot and not specify that the line color is red.


Overloading Varargs Methods in Java, A function that was written with a simple purpose (e.g., to double a number) may be Has one or more input parameters; Performs calculations using only the input value for the same input; Does not use or affect any data outside the function Here is an example of using a vararg parameter to create a summing function  Improve this sample solution and post your code through Disqus. Previous: Write a program in C# Sharp to create a user define function with parameters. Next: Write a program in C# Sharp to create a function to input a string and count number of spaces are in the string.


Custom Java Simple Function Sample, In this article, you'll learn about varargs in Java with the help of examples. What if the user wants to add 5 numbers or 10 or 100? sum of int parameters passed to it (doesn't matter the number of arguments For example, if you are certain that sumNumber() method will be used only to calculate the sum of either 2 or 3  Summary: in this tutorial, you will learn how to use SQL Server SUM() function to calculate the sum of values. The SQL Server SUM() function is an aggregate function that calculates the sum of all or distinct values in an expression. The syntax of the SUM() function is as follows:


Variadic function, Defining a closure; Closures as an object; Calling a closure For instance, "The sum of 1 and 2 is equal to ${def a = 1; def b = 2; a + b}" is supported Conveniently for exact decimal number calculations, Groovy choses java.lang. For example if a method foo takes a varargs argument of type T and another method foo  Java program to calculate the average of N numbers. Here is the code to calculate the average of N numbers or average of 2 or 3 numbers. The following code has been written in three different ways, using standard values, using do while , recursion, command line arguments, creating a separate class, user-defined method.