What is the ellipsis (...) for in this method signature?

java

varargs

method-signature

java-8

byNikita Barsukov·Mar 11, 2025

The ... in a Java method signature represents varargs, which permits you to pass any number of arguments where only one is specified. In effect, it provides a straightforward method to adapt your methods to handle any amount of data.

Here's an illustrative example:

public void log(String... eventsToLog) {
    for (String event : eventsToLog) {
        System.out.println(event);  // Even logging becomes fun with varargs!
    }
}

log("Alien spotted!", "Just joking.");  // Sends 2 messages
log("Coffee break");  // Sends one message
log();  // Sends no messages, but still not an error

Unveiling the mystery: Understanding varargs

The introduction of varargs in Java 1.5 enhanced Java's capability to handle varied counts of arguments, reducing the need to overload methods. Varargs under the hood are treated as arrays which opens up an easy way of handling any number of arguments.

Let's delve into some potential use-cases, common pitfalls, and advanced tips related to varargs:

Usage with Zero Arguments: Varargs allow zero arguments, so ensure your method can tolerate receiving none.
Positional Usage: The varargs declaration should ideally be the last parameter within method parameters list to avoid confusion.
Beware of Overloading: Overloading a varargs method can lead to unexpected behavior. Remember, a method with defined parameters will be preferred over a varargs one.
Memory Considerations: Varargs create an array under the hood, so memory performance would be identical to using arrays. It's negligible for small data volumes but could become significant when dealing with massive data sets.

When varargs shine: Practical Examples

Varargs are designed to make your codes elegant and adaptable. But when exactly do they come in handy? Let's delve into exciting real-world use-cases:

Formatting Messages: Look at String.format("%s %s", "Good", "Day!"): this handy way of crafting sentences wouldn't be possible without varargs.
Localisation: Handling multiple locales becomes a breeze with varargs as in ResourceBundle.getString(String key, Object... args).
Event Management: When firing off multiple events at once, varargs save you from syntax hell, as exemplified by fireEvents(Event... events).

Varargs Pitfalls: Things to watch out for

While varargs are incredibly convenient, they can lead to some obscure issues if you're not cautious:

Heap Pollution: Improper usage of varargs with generic types can cause heap pollution, breaching the security of the type system.
Method Resolution: Varargs methods are resolved last when the compiler resolves overloaded methods. Over-reliance on varargs can lead to unexpected behavior.
Performance: For data-intensive applications, creating arrays behind the scenes can be a substantial overhead. It's often better to pass explicitly created arrays in such cases.