Comment convertir un Kotlin Array en Java varargs : guide complet pour débutants

Kotlin Array dans Java varargs : comment ne pas casser la compatibilité et écrire un code propre

Avez-vous déjà écrit en Kotlin, appelé une bonne vieille méthode Java avec varargs — et soudainement obtenu une erreur de compilation ? Si oui, vous n'êtes pas seul. La question "Convert Kotlin Array to Java varargs" a recueilli des milliers de vues sur Stack Overflow. Et ce n'est pas surprenant : à l'intersection des deux langues, des nuances peu évidentes apparaissent souvent.

Dans cet article, nous allons voir comment transmettre correctement un tableau Kotlin à une méthode Java avec un nombre variable d'arguments. Vous apprendrez ce qu'est l'opérateur spread, pourquoi Array<String> n'est pas égal à String... et comment éviter les erreurs typiques. C'est parti !

Que sont les varargs en Java et à quoi servent-ils

Pour commencer, rappelons les bases. Varargs (arguments de longueur variable) est un mécanisme Java qui permet de transmettre un nombre arbitraire d'arguments d'un même type à une méthode. Syntaxiquement, cela se note par trois points après le type :

public void printMessages(String... messages) {\n    for (String msg : messages) {\n        System.out.println(msg);\n    }\n}

Vous pouvez appeler cette méthode ainsi :

printMessages("Hello");\nprintMessages("Hello", "World");\nprintMessages(); // un appel vide fonctionne aussi

À l'intérieur de la méthode, les arguments sont représentés comme un tableau String[]. Mais de l'extérieur, ce n'est qu'un ensemble de valeurs séparées par des virgules. Pratique, non ?

Et maintenant, imaginez que vous avez un Kotlin Array et que vous voulez le transmettre à une telle méthode Java. Un code naïf ne fonctionnera pas :

val messages = arrayOf("Hello", "World")\nprintMessages(messages) // Erreur de compilation !

Pourquoi ? Parce que Kotlin est plus strict concernant les types. La méthode Java attend String..., et vous transmettez Array<String>. Ce sont des choses différentes. Le compilateur voit l'incompatibilité et génère une erreur.

Solution : l'opérateur spread (opérateur *)

En Kotlin, pour de tels cas, il existe l'opérateur spread — un astérisque * devant le tableau. Il « déploie » littéralement le tableau en éléments individuels, qui sont ensuite transmis comme varargs.

val messages = arrayOf("Hello", "World")\nprintMessages(*messages) // Ça marche !

Tout ce qui est génial est simple. Mais voyons comment cela fonctionne sous le capot.

Comment l'opérateur spread transforme les types

Lorsque vous écrivez *messages, Kotlin :

\n
• Prend chaque élément du tableau
\n
• Les « extrait » de l'emballage Array
\n
• Les transmet comme arguments individuels à la méthode Java
\n

Pour la méthode Java, cela ressemble à si vous aviez écrit printMessages("Hello", "World"). Pas de tableaux — seulement des chaînes pures.

Nuance importante : l'opérateur spread fonctionne uniquement avec Array (et certaines autres collections via toTypedArray()). Un List ordinaire ne peut pas être déployé ainsi.

Erreurs typiques et comment les éviter

Même en connaissant l'opérateur spread, les débutants commettent souvent des erreurs. Voici les plus fréquentes.

Erreur 1 : Transmettre un tableau sans l'astérisque

// Incorrect :\nval numbers = intArrayOf(1, 2, 3)\nsomeJavaMethod(numbers) // Erreur\n\n// Correct :\nsomeJavaMethod(*numbers.toTypedArray())

Remarque : pour les types primitifs (IntArray, DoubleArray, etc.), il faut d'abord les convertir en Array via .toTypedArray(). L'opérateur spread fonctionne uniquement avec les tableaux d'objets.

Erreur 2 : Confusion avec List

Beaucoup essaient de transmettre un List<String> directement :

val list = listOf("A", "B")\nprintMessages(*list) // Erreur ! List != Array

Solution : convertissez d'abord la liste en tableau :

printMessages(*list.toTypedArray())