Les var-args (liste d’arguments variable) sont une nouveauté Java 5, qui rentre dans la catégorie des "syntaxic sugar".
Autrement dit, ce n’est pas indispensable, mais ça rend bien service.

Alors, à quoi ça sert ? Principalement à simplifier le passage de tableaux en paramètre des méthodes.
Voyons comment.

Un premier exemple

Prenons un exemple : afficher un ensemble de Strings.

public void printAll(String[] strings) {
	for (String s : strings) {
		System.out.println(s);
	}
}

Avec la méthode “historique”, il fallait construire un tableau pour passer les Strings en paramètre, comme ceci :

String[] strings = new String[] {"foo", "bar"};
printAll(strings);

ou constuire le tableau directement dans l’appel :

printAll(new String[] {"foo", "bar"});

Les var-args permettent de simplifier cette écriture.
Il suffit de changer légèrement la signature de la méthode (notez les trois points "…" au lieu des crochets) :

public void printAll(String... strings) {
	for(String s : strings) {
		System.out.println(s);
	}
}

Le code d’appel est maintenant plus simple :

printAll("foo", "bar");
printAll("foo", "bar", "baz", "toto");

Un peu de théorie

On peut désormais passer un nombre variable d’arguments (pourvu qu’ils soient tous du type déclaré dans la signature de la méthode, évidemment), sans créer explicitement de tableau ! En revanche, dans le corps de la méthode, la variable var-arg est considéré comme un banal tableau et peut donc être parcourue par un « foreach », fournir sa taille avec la propriété length, etc.

Il y a toutefois deux petites limitations à cette syntaxe :

• Il ne peut y avoir qu’un seul var-arg par signature de méthode
• Le var-arg doit toujours être le dernier paramètre

En pratique, les var-args sont très pratiques pour les setters :

public void setStrings(final String... strings) {
	this.strings = strings;
}

Cette syntaxe peut rendre moins fastidieuse la construction de grappes d'objets reposant lourdement sur des tableaux, comme par exemple lors de l'écriture de mocks pour les tests unitaires. Je vous recommande donc de l’appliquer pour tous vos setters simples prenant des tableaux en paramètre.

En pratique

Combinés aux generics, les var-args permettent de créer des méthodes utilitaires puissantes, flexibles et simples d’utilisation.
Par exemple, voici une méthode permettant de construire une liste à partir des objets passés en paramètre.

public static <T> List<T> toList(T... elements) {
	if (elements == null) {
		return Collections.<T> emptyList();
	}
	List<T> list = new ArrayList<T>();
	for (T element : elements) {
		list.add(element);
	}
	return list;
}

Cette méthode est simple à utiliser :

List<String> strings = Utils.toList("foo", "bar", "baz", "toto");