Initialisation d'une ArrayList sur une seule ligne

2757

Je voulais créer une liste d'options à des fins de test. Au début, je l'ai fait:

ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");

Ensuite, j'ai refactorisé le code comme suit:

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Y a-t-il une meilleure manière de faire cela?

Macarse
la source
34
Si cela est destiné à des tests unitaires, essayez de groovy pour une balançoire. Vous pouvez y écrire votre code de test pendant le test du code java et l'utiliserArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"]
ripper234
3
Dans Java SE 7, vous pouvez remplacer le type paramétré du constructeur par un ensemble vide de paramètres de type (<>): Map <String, List <String>> myMap = new HashMap <> ();
Rose
2
utiliser l'initialisation à double contreventement :)
Mohammadreza Khatami
8
Stream.of ("val1", "val2"). Collect (Collectors.toList ()); // crée ArrayList, solution Java8.
torina

Réponses:

2025

En fait, probablement la "meilleure" façon d'initialiser la ArrayListest la méthode que vous avez écrite, car elle n'a pas besoin d'en créer une nouvelle List:

ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

Le hic, c'est qu'il y a pas mal de frappe nécessaire pour faire référence à cette listinstance.

Il existe des alternatives, telles que la création d'une classe interne anonyme avec un initialiseur d'instance (également appelée "initialisation à double accolade"):

ArrayList<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};

Cependant, je n'aime pas trop cette méthode parce que vous vous retrouvez avec une sous-classe ArrayListqui a un initialiseur d'instance, et cette classe est créée juste pour créer un objet - cela semble juste un peu exagéré pour moi.

Ce qui aurait été bien, c'était que la proposition Collection Literals pour Project Coin ait été acceptée (elle devait être introduite dans Java 7, mais elle ne devrait pas non plus faire partie de Java 8):

List<String> list = ["A", "B", "C"];

Malheureusement, cela ne vous aidera pas ici, car il initialisera un immuable Listplutôt qu'un ArrayList, et en outre, il n'est pas encore disponible, s'il le sera jamais.

coobird
la source
172
Voir stackoverflow.com/questions/924285 pour plus d'informations sur l'initialisation à double accolade, les avantages et les inconvénients.
Eddie
6
@Eddie: Bon appel pour le lien - une phrase sur l'initialisation à double accolade ne suffit pas pour le décrire complètement.
coobird
2
Fonctionne uniquement si vous ne comptez pas sur la liste de boxe automatique <Double> list = [1.0, 2.0, 3.0]; échoue.
Richard B
1
Vous manquez un point-virgule sur l'initialisation de la double liste
Don Larynx
6
Étant donné que cette réponse est le Project Coin le plus voté et le plus mentionné, je pense que vous devriez rappeler que java 9 est livré avec la syntaxe List.of (...): docs.oracle.com/javase/9/docs/api/java/util/ List.html # of-E ...-
Asaf
2156

Ce serait plus simple si vous deviez simplement le déclarer comme List- doit-il être un ArrayList?

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Ou si vous n'avez qu'un seul élément:

List<String> places = Collections.singletonList("Buenos Aires");

Cela signifierait que placesc'est immuable (essayer de le changer entraînera la UnsupportedOperationExceptionlevée d' une exception).

Pour créer une liste mutable concrète, ArrayListvous pouvez en créer une à ArrayListpartir de la liste immuable:

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
À M
la source
18
@Marcase: ne pouvez-vous pas changer votre classe pour utiliser une liste au lieu d'ArrayList?
Lawrence Dol
74
Selon ma réponse, si vous n'utilisez pas de méthodes spécifiques à ArrayList, il serait préférable de modifier la déclaration en List. Spécifiez les interfaces, pas les implémentations.
Christoffer Hammarström
9
@Christoffer Hammarström: s'il change la déclaration en List et utilise List <String> places = Arrays.asList (...); il ne pourra pas utiliser places.add ("blabla")
maks
57
Juste pour être clair, asList(...)renvoie une taille fixe Listqui explose lors d'opérations de mutation comme removeet clear, ce que le Listcontrat prétend prendre en charge. Même si vous avez laissé la déclaration as List, vous devrez toujours l'utiliser List l = new ArrayList(asList(...))pour obtenir un objet qui ne lève pas d'exceptions OperationNotSupported. Liskov Principe de substitution quelqu'un?
Splash
5
@Splash: removeet clearsont des opérations optionnelles dans List, asList(...)suit donc le contrat. Nulle part le PO ne dit qu'il a besoin d'ajouter plus d'éléments plus tard, l'exemple est juste Listcelui qui doit être initialisé avec trois éléments.
Christoffer Hammarström
872

La réponse simple

Dans Java 9 ou version ultérieure, après a List.of()été ajouté:

List<String> strings = List.of("foo", "bar", "baz");

Avec Java 10 ou version ultérieure, cela peut être raccourci avec le varmot - clé.

var strings = List.of("foo", "bar", "baz");

Cela vous donnera une immuable List , donc il ne peut pas être changé.
C'est ce que vous voulez dans la plupart des cas où vous le préremplissez.


Java 8 ou version antérieure:

List<String> strings = Arrays.asList("foo", "bar", "baz");

Cela vous donnera un Listsoutenu par un tableau, donc il ne peut pas changer de longueur.
Mais vous pouvez appeler List.set, donc c'est toujours mutable .


Vous pouvez Arrays.asListraccourcir encore plus avec une importation statique:

List<String> strings = asList("foo", "bar", "baz");

L'importation statique:

import static java.util.Arrays.asList;  

Ce que n'importe quel IDE moderne suggérera et fera automatiquement pour vous.
Par exemple, dans IntelliJ IDEA, vous appuyez sur Alt+Enteret sélectionnezStatic import method... .


Cependant, je ne recommande pas de raccourcir la List.ofméthode of, car cela devient déroutant.
List.ofest déjà assez court et se lit bien.


En utilisant Stream s

Pourquoi faut-il que ce soit un List?
Avec Java 8 ou version ultérieure, vous pouvez utiliser un Streamqui est plus flexible:

Stream<String> strings = Stream.of("foo", "bar", "baz");

Vous pouvez concaténer Streams:

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

Ou vous pouvez passer de a Streamà a List:

import static java.util.stream.Collectors.toList;

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

Mais de préférence, utilisez simplement le Streamsans le ramasser à un List.


Si vous avez vraiment besoin d'unjava.util.ArrayList

(Vous ne le faites probablement pas.)
Pour citer JEP 269 (c'est moi qui souligne):

Il existe un petit ensemble de cas d'utilisation pour initialiser une instance de collection mutable avec un ensemble de valeurs prédéfinies. Il est généralement préférable que ces valeurs prédéfinies se trouvent dans une collection immuable, puis d'initialiser la collection mutable via un constructeur de copie.


Si vous souhaitez à la fois préremplir un ArrayList et y ajouter par la suite (pourquoi?), Utilisez

ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");

ou en Java 8 ou version antérieure:

ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");

ou en utilisant Stream:

import static java.util.stream.Collectors.toCollection;

ArrayList<String> strings = Stream.of("foo", "bar")
                             .collect(toCollection(ArrayList::new));
strings.add("baz");

Mais encore une fois, il vaut mieux utiliser Streamdirectement le au lieu de le collecter dans unList .


Programme aux interfaces, pas aux implémentations

Vous avez déclaré avoir déclaré la liste en tant que ArrayListdans votre code, mais vous ne devriez le faire que si vous utilisez un membre deArrayList qui n'en fait pas partie List.

Ce que vous ne faites probablement pas.

Habituellement , vous devez simplement déclarer des variables par la plus interface générale que vous allez utiliser (par exemple Iterable, Collectionou List), et les initialiser avec la mise en œuvre spécifique (par exemple ArrayList, LinkedListouArrays.asList() ).

Sinon, vous limitez votre code à ce type spécifique, et il sera plus difficile de changer quand vous le souhaitez.

Par exemple, si vous passez d'un ArrayListà un void method(...):

// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) { 
    for (String s : strings) { ... } 
}

// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
    if (!strings.isEmpty()) { strings.stream()... }
}

// List if you also need .get(index):
void method(List<String> strings) {
    strings.get(...)
}

// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
    ??? // You don't want to limit yourself to just ArrayList
}

Un autre exemple serait de toujours déclarer une variable an InputStreammême s'il s'agit généralement d'un FileInputStreamou d'un BufferedInputStream, car un jour prochain, vous ou quelqu'un d'autre voudrez utiliser un autre type de InputStream.

Christoffer Hammarström
la source
3
@jollyroger: Arrays.asListest une méthode statique. Voir docs.oracle.com/javase/1.5.0/docs/guide/language/…
Christoffer Hammarström
2
@ ChristofferHammarström Dans ce cas, mon esprit novice me dit que l'importation statique présente une forte ressemblance avec les variables globales et les dangers qui se rapportent à une telle utilisation. Cette hypothèse est-elle correcte et est-ce aussi la raison pour laquelle la réponse similaire ci-dessus obtient plus de votes?
jollyroger
2
La réponse ci-dessus je pense que vous parlez a été faite un an auparavant. Et non, le problème avec les variables globales est qu'elles sont mutables. Ils n'ont rien à voir avec les importations statiques.
Christoffer Hammarström
2
Si vous ne voulez pas l'importation statique, vous pouvez également définir le chemin d'accès complet à la méthode asList statique, comme suit: List <String> strings = java.util.Arrays.asList ("", "");
Geert Weening du
2
Ou vous pouvez utiliser import java.util.Arrays; et Arrays.asList ("", ""); Vous n'avez pas besoin d'utiliser une importation statique. Vous n'avez pas besoin d'utiliser un chemin complet. Les méthodes statiques ne se soucient pas de l'importation. Ils sont simplement ennuyés si vous utilisez une instance pour les trouver.
candied_orange
111

Si vous avez besoin d'une simple liste de taille 1:

List<String> strings = new ArrayList<String>(Collections.singletonList("A"));

Si vous avez besoin d'une liste de plusieurs objets:

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");
Randyaa
la source
57

Avec la goyave, vous pouvez écrire:

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

À Guava, il existe également d'autres constructeurs statiques utiles. Vous pouvez en lire plus ici .

Paweł Adamski
la source
1
Je suis à peu près sûr que vous pouvez le faire avec, java.util.Arrayspar exemple,List<String> names = Arrays.asList("Beckah", "Sam", "Michael");
Beckah
2
La méthode @beckah Arrays.asLists crée un objet de type List, tandis que la question porte sur la création d'ArrayList
Paweł Adamski
34

Les littéraux de collection ne sont pas entrés dans Java 8, mais il est possible d'utiliser l'API Stream pour initialiser une liste sur une assez longue ligne:

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

Si vous devez vous assurer que vous êtes Listun ArrayList:

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));
marque
la source
34

Avec et au-dessus, comme suggéré dans JEP 269: Convenience Factory Methods for Collections , ceci pourrait être réalisé en utilisant les littéraux de collection maintenant avec -

List<String> list = List.of("A", "B", "C");

Set<String> set = Set.of("A", "B", "C");

Une approche similaire s'appliquerait Mapégalement -

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

qui est similaire à la proposition Collection Literals comme indiqué par @coobird. Également clarifié dans le JEP -


Alternatives

Les changements de langue ont été envisagés à plusieurs reprises et rejetés:

Project Coin Proposition, 29 mars 2009

Project Coin Proposition, 30 mars 2009

Discussion du JEP 186 sur lambda-dev, janvier-mars 2014

Les propositions linguistiques ont été mises de côté de préférence à une proposition basée sur la bibliothèque, comme résumé dans ce message.

En relation: Quel est l'intérêt des méthodes surchargées de Convenience Factory pour les collections dans Java 9

Naman
la source
31
import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
George
la source
4
Je ne veux pas ajouter une nouvelle dépendance juste pour cela.
Macarse
6
C'est la même chose que Collections.unmodifiableList(Arrays.asList("Buenos Aires", "Córdoba", "La Plata")), ce qui devient unmodifiableList(asList("Buenos Aires", "Córdoba", "La Plata"))avec les importations statiques. Vous n'avez pas besoin de Google Collections pour cela.
Christoffer Hammarström
9
Non, ce n'est pas pareil. Comme ImmutableList documente son immuabilité dans le type de résultat lorsque unmodifiableList le masque comme une liste normale.
David Pierre
2
Au lieu de l'immuable, les collections Google proposent également une liste de tableaux modifiables: List <String> = Lists.newArrayList ("Buenos Aires", "Córdoba", "La Plata");
L. Holanda
3
Vous allez transmettre cela ImmutableListà d'autres méthodes qui prennent un List, puis vous avez de toute façon perdu cette documentation.
Christoffer Hammarström
23

Vous pouvez créer une méthode d'usine:

public static ArrayList<String> createArrayList(String ... elements) {
  ArrayList<String> list = new ArrayList<String>();
  for (String element : elements) {
    list.add(element);
  }
  return list;
}

....

ArrayList<String> places = createArrayList(
  "São Paulo", "Rio de Janeiro", "Brasília");

Mais ce n'est pas beaucoup mieux que votre premier refactoring.

Pour plus de flexibilité, il peut être générique:

public static <T> ArrayList<T> createArrayList(T ... elements) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : elements) {
    list.add(element);
  }
  return list;
}
Jordão
la source
1
Revenez au message d'origine, il demande l'initialisation du tableau sur une seule ligne , pas 7 lignes supplémentaires.
L. Holanda
7
@LeoHolanda: Créer des méthodes d'usine pour chaque petite chose est trop, je suis d'accord. Mais selon la situation et le nombre de fois que cette méthode sera utilisée, il pourrait être judicieux de la créer. La création de couches d'abstraction supplémentaires vise à éliminer la complexité, en créant des méthodes plus significatives qui capturent l' intention du concepteur.
Jordão
16

Dans Java 9, nous pouvons facilement initialiser un ArrayListsur une seule ligne:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

ou

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Cette nouvelle approche de Java 9 présente de nombreux avantages par rapport aux précédentes:

  1. Efficacité spatiale
  2. Immutabilité
  3. Thread Safe

Voir cet article pour plus de détails -> Quelle est la différence entre List.of et Arrays.asList?

Mohit Tyagi
la source
8

À propos de la façon la plus compacte de procéder:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);
Richard B
la source
8

Utilisez simplement le code ci-dessous comme suit.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};
user2801794
la source
2
@bsd Vous pouvez utiliser cette méthode pour déclarer la liste avant de saisir une méthode. Ainsi, lors de la définition des variables de classe, le contenu peut être ajouté à la liste sans avoir à appeler une méthode pour le faire.
melwil
2
l'initialisation des accolades doit être évitée autant que possible. voir: stackoverflow.com/a/924326/760393
Raúl
8

Avec Eclipse Collections, vous pouvez écrire ce qui suit:

List<String> list = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");

Vous pouvez également être plus précis sur les types et s'ils sont mutables ou immuables.

MutableList<String> mList = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableList<String> iList = Lists.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Vous pouvez également faire de même avec les ensembles et les sacs:

Set<String> set = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableSet<String> mSet = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet<String> iSet = Sets.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Bag<String> bag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableBag<String> mBag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableBag<String> iBag = Bags.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Remarque: je suis un committer pour les collections Eclipse.

Donald Raab
la source
7

Voici une autre façon:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());
Henok T
la source
7

(Doit être un commentaire, mais trop long, donc nouvelle réponse). Comme d'autres l'ont mentionné, la Arrays.asListméthode est de taille fixe, mais ce n'est pas le seul problème. Il ne gère pas non plus très bien l'héritage. Par exemple, supposons que vous ayez les éléments suivants:

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

Ce qui précède entraîne une erreur de compilation, car List<B>(ce qui est renvoyé par Arrays.asList) n'est pas une sous-classe de List<A>, même si vous pouvez ajouter des objets de type B à un List<A>objet. Pour contourner cela, vous devez faire quelque chose comme:

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

C'est probablement la meilleure façon de procéder, en particulier. si vous avez besoin d'une liste illimitée ou devez utiliser l'héritage.

user439407
la source
6

Vous pouvez utiliser les déclarations ci-dessous:

Extrait de code:

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);
rashedcs
la source
Vous pouvez incorporer la première expression pour avoir une solution compacte:letters = Arrays.asList(new String[]{"A", "B", "C"});
Pavel Repin
5

Comme l'a dit Tom :

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Mais puisque vous vous êtes plaint de vouloir une ArrayList, vous devez d'abord savoir que ArrayList est une sous-classe de List et vous pouvez simplement ajouter cette ligne:

ArrayList<String> myPlaces = new ArrayList(places);

Cependant, cela pourrait vous faire vous plaindre de «performances».

Dans ce cas, cela n'a pas de sens pour moi, pourquoi, puisque votre liste est prédéfinie, elle n'a pas été définie comme un tableau (car la taille est connue au moment de l'initialisation). Et si c'est une option pour vous:

String[] places = {"Buenos Aires", "Córdoba", "La Plata"};

Si vous ne vous souciez pas des différences de performances mineures, vous pouvez également copier un tableau dans une liste de tableaux très simplement:

ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));

D'accord, mais à l'avenir, vous aurez besoin d'un peu plus que le nom du lieu, vous avez également besoin d'un code de pays. En supposant qu'il s'agit toujours d'une liste prédéfinie qui ne changera jamais pendant l'exécution, il convient d'utiliser un enumensemble, qui nécessiterait une recompilation si la liste devait être modifiée à l'avenir.

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

deviendrait:

enum Places {
    BUENOS_AIRES("Buenos Aires",123),
    CORDOBA("Córdoba",456),
    LA_PLATA("La Plata",789);

    String name;
    int code;
    Places(String name, int code) {
      this.name=name;
      this.code=code;
    }
}

Les valuesénumérations ont une méthode statique qui renvoie un tableau contenant toutes les valeurs de l'énumération dans l'ordre où elles sont déclarées, par exemple:

for (Places p:Places.values()) {
    System.out.printf("The place %s has code %d%n",
                  p.name, p.code);
}

Dans ce cas, je suppose que vous n'auriez pas besoin de votre ArrayList.

PS Randyaa a démontré une autre belle façon d'utiliser la méthode utilitaire statique Collections.addAll .

Ozzy
la source
5

Java 9 a la méthode suivante pour créer une liste immuable :

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

qui est facilement adapté pour créer une liste mutable, si nécessaire:

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Des méthodes similaires sont disponibles pour Setet Map.

user85421
la source
1
C'est bien que vous ayez explicitement dit "liste immuable" et que vous ayez ensuite montré un autre exemple de liste mutable car cela indique clairement lequel utiliser quand.
cherit
4
List<String> names = Arrays.asList("2","@2234","21","11");
Ran Adler
la source
4

Oui, à l'aide des tableaux, vous pouvez initialiser la liste des tableaux sur une seule ligne,

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");
Akash Manngroliya
la source
4

Vous pouvez utiliser StickyListde Cactoos :

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);
yegor256
la source
3

Essayez avec cette ligne de code:

Collections.singletonList(provider)
Ant20
la source
1
Ajoutez une brève description de votre réponse.
Morales Batovski
2

En Java, vous ne pouvez pas faire

ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Comme cela a été souligné, vous devez effectuer une initialisation à double accolade:

List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};

Mais cela peut vous forcer à ajouter une annotation @SuppressWarnings("serial")ou générer un UUID série qui est ennuyeux. De plus, la plupart des formateurs de code déplieront cela en plusieurs instructions / lignes.

Vous pouvez également faire

List<String> places = Arrays.asList(new String[] {"x", "y" });

mais alors vous voudrez peut-être faire un @SuppressWarnings("unchecked").

Toujours selon javadoc, vous devriez pouvoir faire ceci:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Mais je ne parviens pas à le compiler avec JDK 1.6.

Dawg
la source
5
Faux! Vous pouvez faire la première ligne, et c'est la bonne réponse btw
Bohème
1
Collections.singletonList(messageBody)

Si vous aviez besoin d'avoir une liste d' un article !

Les collections proviennent du package java.util .

ViliusK
la source
1

La meilleure façon de le faire:

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

Créez simplement une fonction qui peut avoir autant d'éléments que vous le souhaitez et appelez-la pour les ajouter sur une seule ligne.

Charif DZ
la source
1
Si vous rencontrez tous les problèmes, vous pourriez aussi bien en faire une méthode de modèle au lieu d'utiliser plain Object.
Robert
1

Voici le code d' AbacusUtil

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

Déclaration: je suis le développeur d'AbacusUtil.

user_3380739
la source
0

Pour moi, Arrays.asList () est le meilleur et le plus pratique. J'aime toujours initialiser de cette façon. Si vous êtes un débutant dans les collections Java, je voudrais que vous fassiez référence à l' initialisation de ArrayList

Manoj Kumar
la source
Pourquoi Arrays.asList () est-il meilleur que de créer un nouveau ArrayList sur une seule ligne avec des add()méthodes?
IgorGanapolsky
0

Pourquoi ne pas faire une fonction utilitaire simple qui fait cela?

static <A> ArrayList<A> ll(A... a) {
  ArrayList l = new ArrayList(a.length);
  for (A x : a) l.add(x);
  return l;
}

" ll" signifie "liste littérale".

ArrayList<String> places = ll("Buenos Aires", "Córdoba", "La Plata");
Stefan Reich
la source
0

fait intéressant, aucun one-liner avec l'autre méthode surchargée Stream::collect n'est répertorié

ArrayList<String> places = Stream.of( "Buenos Aires", "Córdoba", "La Plata" ).collect( ArrayList::new, ArrayList::add, ArrayList::addAll );
Kaplan
la source
-1

En fait, il est possible de le faire en une seule ligne:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})
Adrian
la source
3
Puis-je demander ce que cela ajoute à la question? Cette réponse est déjà couverte plusieurs fois par d'autres réponses.
Mysticial
Il s'agit en fait d'une très mauvaise solution car elle crée une LISTE ABSTRAITE. Vous ne pourrez rien ajouter de plus au conteneur.
Atais