Disons que j'ai une méthode m () qui prend un tableau de chaînes comme argument. Existe-t-il un moyen de déclarer ce tableau en ligne lorsque je fais l'appel? c'est-à-dire au lieu de:

String[] strs = {"blah", "hey", "yo"};
m(strs);

Puis-je simplement remplacer cela par une ligne et éviter de déclarer une variable nommée que je ne vais jamais utiliser?

m(new String[]{"blah", "hey", "yo"});

Draemon a raison. Vous pouvez également déclarer mque vous prenez des varargs :

void m(String... strs) {
    // strs is seen as a normal String[] inside the method
}

m("blah", "hey", "yo"); // no [] or {} needed; each string is a separate arg here

Une autre façon de le faire, si vous voulez que le résultat soit une liste en ligne, vous pouvez le faire comme ceci:

Arrays.asList(new String[] { "String1", "string2" });

Vous pouvez directement écrire le tableau en Java moderne, sans initialiseur. Votre exemple est maintenant valide. Il est généralement préférable de nommer le paramètre de toute façon.

String[] array = {"blah", "hey", "yo"};

ou

int[] array = {1, 2, 3};

Si vous devez vous aligner, vous devrez déclarer le type:

functionCall(new String[]{"blah", "hey", "yo"});

ou utilisez des varargs (arguments variables)

void functionCall(String...stringArray) {
    // Becomes a String[] containing any number of items or empty
}

functionCall("blah", "hey", "yo");

Espérons que les développeurs de Java permettront l'initialisation implicite à l' avenir

Mise à jour: réponse Kotlin

Kotlin a rendu le travail avec les tableaux tellement plus facile! Pour la plupart des types, utilisez simplement arrayOfet cela déterminera implicitement le type. Ne passez rien pour les laisser vides.

arrayOf("1", "2", "3") // String
arrayOf(1, 2, 3)       // Int
arrayOf(1, 2, "foo")   // Any 
arrayOf<Int>(1, 2, 3)  // Set explict type
arrayOf<String>()      // Empty String array

Les primitives ont des fonctions utilitaires. Ne passez rien pour les laisser vides.

intArrayOf(1, 2, 3)
charArrayOf()
booleanArrayOf()
longArrayOf()
shortArrayOf()
byteArrayOf()

Si vous en avez déjà un Collectionet que vous souhaitez le convertir en tableau en ligne, utilisez simplement:

collection.toTypedArray()

Si vous devez contraindre un type de tableau, utilisez:

array.toIntArray()
array.toLongArray()
array.toCharArray()
...

Vous pouvez créer une méthode quelque part

public static <T> T[] toArray(T... ts) {
    return ts;
}

alors utilise-le

m(toArray("blah", "hey", "yo"));

pour un meilleur look.

Je voudrais ajouter que la syntaxe d'initialisation du tableau est très succincte et flexible. Je l'utilise beaucoup pour extraire des données de mon code et les placer dans un endroit plus utilisable.

Par exemple, j'ai souvent créé des menus comme celui-ci:

Menu menu=initMenus(menuHandler, new String[]{"File", "+Save", "+Load", "Edit", "+Copy", ...});

Cela me permettrait d'écrire du code venu pour configurer un système de menus. Le "+" suffit pour lui dire de placer cet élément sous l'élément précédent.

Je pourrais le lier à la classe menuHandler soit par une convention de dénomination de méthode en nommant mes méthodes quelque chose comme "menuFile, menuFileSave, menuFileLoad, ..." et en les liant de manière réfléchie (il existe d'autres alternatives).

Cette syntaxe permet une définition de menu incroyablement brève et une méthode "initMenus" extrêmement réutilisable. (Pourtant, je ne me soucie pas de le réutiliser car il est toujours amusant à écrire et ne prend que quelques minutes + quelques lignes de code).

chaque fois que vous voyez un modèle dans votre code, voyez si vous pouvez le remplacer par quelque chose comme ça, et rappelez-vous toujours à quel point la syntaxe d'initialisation du tableau est succincte!.

Une autre option consiste à utiliser ArrayUtils.toArray dans org.apache.commons.lang3

ArrayUtils.toArray("elem1","elem2")

Comme le dit Draemon, le plus proche que Java vient des tableaux en ligne est new String[]{"blah", "hey", "yo"}cependant il y a une astuce qui vous permet de faire quelque chose comme

array("blah", "hey", "yo") avec le type déduit automatiquement.

J'ai travaillé sur une API utile pour augmenter le langage Java afin de permettre les tableaux en ligne et les types de collection. Pour plus de détails sur le projet Google Espresso4J ou consultez-le ici