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?

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.

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"));

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.

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");

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 .

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));

Avec java-9et 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

import com.google.common.collect.ImmutableList;

....

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

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;
}

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?

À 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);

Utilisez simplement le code ci-dessous comme suit.

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

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.

Voici une autre façon:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());

(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.

Vous pouvez utiliser les déclarations ci-dessous:

Extrait de code:

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

List<String> names = Arrays.asList(arr);

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 .

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.

List<String> names = Arrays.asList("2","@2234","21","11");

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

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");

Vous pouvez utiliser StickyListde Cactoos :

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

Essayez avec cette ligne de code:

Collections.singletonList(provider)

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.

Collections.singletonList(messageBody)

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

Les collections proviennent du package java.util .

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.

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.

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

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");

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 );

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

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})