There isn't really replacement to va_args in c and C++. Such typeless interfaces violate the underlying philosophies of Java. So you'll never be able to write a method like

If there's a need for a variable list of arguments you'll can take advantage of the singly-rooted object heirarchy and pack a collection of objects as pass them into the method, where you'll unpack them again. This isn't as pretty, but it will give you the flexibiliy you want. But note that the object purists will tell you that the kind of functionality you want is a sign of a sick design, and you may want to spend some time re-thinking your API to see if maybe something can be refactored to solve the problem more elegantly.

I can think of two solutions.

First, use method overloading. Java allows you to use the same method name with different parameters. For instance, all of the following methods can be used in the same class:

int indexOf(int ch, int fromIndex)
int indexOf(String str)
int indexOf(String str, int fromIndex)

These three methods (from the String class) have the same name and return type, but use different, 'optional' parameters.

The second option is to pass an enumerate of general data types to the method, and have the method decide what needs to be done.

public String myMethod (String str, Vector v)
or
public String myMethod (String str, Object [] objs)

Within that Vector or Object array, you could store hundreds of optional arguments.

Parsing these, in no particular order, won't be fun or pretty. Also, this really isn't good coding style, because an evil programmer could abuse this method, and possibly make things nasty for you. However, it is a hack that will work.

Unlike C and C++, Java has no special syntax to indicate
that a method may accept a variable number of arguments.
You can, however, acheive the same functionality
by simply overloading your methods. For example,
java.lang.String has 11 constructor methods,
each of which accept a different number and/or type of
arguments.

While overloading is good when you know what combinations
of arguments may be used, if you wish to accept an
unbounded number of arguments you should pass these
in as an array or some other data structure.

public void myMethod(int a, int b, int c) {
    // Do something...
}


public void myMethod(int a, int b) {
    // Call myMethod with a default value
    myMethod(a, b, 0);
}


public void myMethod(int a) {
    // Call myMethod with default values
    myMethod(a, -1, 0);
}

public static void method(Object[] params);

You have to convert event the primitive
types like int to Integer objects.

This is how java.lang.reflect package deals
with variable arguments. In fact, You can find many example of that in java.text package also.

You can always use overloaded methods, but I guess you are looking for a compact single
method like C/C++ printf.

They are working on a JSR to make it easy -

http://java.sun.com/aboutJava/communityprocess/jsr/jsr_065_cncsarray.html