Comment créer une nouvelle Liste en Java

Nous créer un Set comme:

Set myset = new HashSet()

Comment pouvons-nous créer un List en Java?

  • Sur la javadoc de la Liste. "Tous Connu La Mise En Œuvre De Classes: AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Pile, Vecteur"
  • Cette question est l'un des meilleurs résultats google pour "java créer une liste" et il est très utile de définir des réponses, afin d'semble raisonnable assez de question pour moi 🙂
  • C'est une bonne question avec les bonnes réponses. L'un des objectifs de Débordement de Pile est de créer une sorte de réponse canonique pour les questions de programmation, au moins selon les fondateurs du site. Donc essayez d'éviter le droit de vote de ces types de postes dans l'avenir, si vous pouvez résister à la tentation.
InformationsquelleAutor user93796 | 2009-05-13
  1. 883
    List myList = new ArrayList();

    ou avec les génériques (Java 7 ou plus tard)

    List<MyType> myList = new ArrayList<>();

    ou avec les génériques (les Anciennes versions de java)

    List<MyType> myList = new ArrayList<MyType>();
    • Notez que ArrayList n'est pas le seul type de Liste-et, s'agissant de la question, HashSet est pas le seul type de Jeu.
    • Je suis surpris que personne n'a mentionné que, vous pouvez consulter la liste de l'interface dans la documentation de Java pour obtenir une liste définitive de toutes les classes qui implémentent la Liste: docs.oracle.com/javase/7/docs/api/java/util/List.html
    • Si vous utilisez un IDE, vous pouvez généralement voir une hiérarchie de type y, qui peut être plus pratique. Dans Eclipse, le raccourci par défaut est de F4, et dans l'IDÉE c'est Ctrl+H.
    • À partir de ce que je comprends, vous ne pouvez pas utiliser des génériques avec liste de tableaux en C# MSDN
    • L'équivalent de ArrayList<> en C# est une Liste<>()
    • La seconde explicite argument de type <MyType> peut être remplacé par seulement <> pour Java 7 et 8.
    • En Java 9, Liste.d'("élément1","item2") est la méthode la plus simple et la plus concise façon de le faire - mais attention, il crée une liste immuable.

    InformationsquelleAutor Dan Vinton
  2. 421

    En outre, si vous souhaitez créer une liste qui a des choses en elle (bien qu'elle sera de taille fixe):

    List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");
    • Le problème, c'est que ce type de liste (celui retourné par asList()) est immuable.
    • faux: il n'est de taille fixe: vous ne pouvez pas changer la taille, mais vous pouvez modifier le contenu (mise en garde de la mise en garde?)
    • Génial. Merci d'être concis.
    • si il n'y a qu'une chose dans la liste, j'ai utiliser des Collections.singletonList() au lieu des Tableaux.asList(). (Mais, je suppose, je ne sais pas pourquoi.)
    InformationsquelleAutor Aaron Maenpaa
  3. 167

    Permettez-moi de résumer et d'ajouter quelque chose:

    JDK

    1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

    Goyave

    1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

    Liste Immuable

    1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));
2. ImmutableList.builder()                                      //Guava
            .add("A")
            .add("B").build();
3. ImmutableList.of("A", "B");                                  //Guava
4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     //Guava

    Vide Liste immuable

    1. Collections.emptyList();
2. Collections.EMPTY_LIST;

    Liste de Caractères

    1. Lists.charactersOf("String")                                 //Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  //Guava

    Liste d'Entiers

    Ints.asList(1,2,3);                                             //Guava
    • Ints.asList ne pas créer une liste immuable, mais une taille fixe la liste soutenue par tableau d'entiers (c'est à dire qu'il prend en charge List.set(int, Object)). Deuxième exemple de "Immuable Liste de Caractères" n'est pas immuable, soit (je l'avais supprimer cette ligne).
    • Ne pas utiliser les génériques fait vraiment un "bon" exemple pour tout développeur qui va lire ce.
    InformationsquelleAutor Sergii Shevchyk
  4. 38

    Dans Java 8

    Pour créer une liste vide de taille fixe (opérations comme ajouter, supprimer, etc., ne sont pas pris en charge):

    List<Integer> list = Arrays.asList(1, 2); //but, list.set(...) is supported

    Pour créer un non-vide mutable liste:

    List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));

    En Java 9

    À l'aide d'un nouveau Liste.de(...) statique usine méthodes:

    List<Integer> immutableList = List.of(1, 2);

List<Integer> mutableList = new ArrayList<>(List.of(3, 4));

    En Java 10

    À l'aide de la Variable Locale De L'Inférence De Type:

    var list1 = List.of(1, 2);

var list2 = new ArrayList<>(List.of(3, 4));

var list3 = new ArrayList<String>();

    Et de suivre les meilleures pratiques...

    Ne pas utiliser des types

    Depuis Java 5, les médicaments génériques ont été une partie de la langue, et vous devez les utiliser:

    List<String> list = new ArrayList<>(); //Good, List of String

List list = new ArrayList(); //Bad, don't do that!

    Programme d'interfaces

    Par exemple, programme de la List interface:

    List<Double> list = new ArrayList<>();

    Au lieu de:

    ArrayList<Double> list = new ArrayList<>(); //This is a bad idea!
    InformationsquelleAutor Oleksandr Pyrohov
  5. 30

    Première lecture cette, alors lisez la cette et cette. 9 fois sur 10, vous pourrez utiliser l'un de ces deux implémentations.

    En fait, il suffit de lire Soleil du Guide des Collections cadre.

    • J'irais même jusqu'à ajouter "8 fois sur 10", vous allez utiliser ArrayList, tout simplement parce que cela n'a pas d'importance dans 9,9 fois sur 10.
    • LinkedList est sémantiquement approprié lorsque vous ne se soucient vraiment de fin.
    • LinkedLists sont excellentes si vous ne sont tout simplement va itérer sur eux. Au mee, il me semble que si les listes chaînées sont plus élégant, mais peut-être que c'est juste parce que j'ai appris lisp avant de Java.
    • D'accord. Je dirais que c'est environ 50/50, la plupart du temps entre ArrayList et LinkedList, et la réponse n'est pas toujours à propos de la complexité des opérations, le plus souvent, c'est tout simplement ce qui se sent le droit pour le problème à la main.
    • J'ai presque toujours utilisé ArrayList. Si je suis le seul à travailler avec la fin de la liste, c'est un deque (ou de la file d'attente) et j'utilise le ArrayDeque mise en œuvre. La raison en est que, même si le tableau implémentations basées à déchets de la mémoire sur les logements vides (quand je ne peux pas prédire la capacité nécessaire), pour les petites collections ceci est comparable à la surcharge de tout le nœud de cas dans une liste (ou deque). Et en retour, je reçois un accès aléatoire. Quel avantage unique ne LinkedList fournir?
    InformationsquelleAutor Adam Jaskiewicz
  6. 21
    //simple example creating a list form a string array

String[] myStrings = new String[] {"Elem1","Elem2","Elem3","Elem4","Elem5"};

List mylist = Arrays.asList(myStrings );

//getting an iterator object to browse list items

Iterator itr= mylist.iterator();

System.out.println("Displaying List Elements,");

while(itr.hasNext())

  System.out.println(itr.next());
    InformationsquelleAutor Blerta
  7. 21

    Depuis Java 7, vous avez l'inférence de type pour les génériques de création d'instance, donc il n'est pas nécessaire de dupliquer les paramètres génériques sur le côté droit de la cession:

    List<String> list = new ArrayList<>();

    Une taille fixe la liste peut être définie comme:

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

    Pour immuable listes, vous pouvez utiliser le Goyave bibliothèque:

    List<String> list = ImmutableList.of("foo", "bar");
    • J'ai une question concernant cette déclaration List<String> liste = Arrays.asList("foo", "bar"); je me demande si la liste dans la déclaration est un objet ?
    InformationsquelleAutor Vitalii Fedorenko
  8. 20

    Liste est juste une interface comme Ensemble.

    Comme HashSet est une mise en œuvre d'un Ensemble qui a certaines propriétés en ce qui concerne à ajouter /recherche /suppression de performance, ArrayList est le nu de la mise en œuvre d'une Liste.

    Si vous avez un coup d'oeil à la documentation pour les interfaces, vous trouverez Tous Connu la mise en Œuvre de Classes" et vous pouvez décider lequel est le plus adapté à vos besoins.

    Les Chances sont que c'est ArrayList.

    InformationsquelleAutor Sorin Mocanu
  9. 16

    List est une interface comme Set et a ArrayList et LinkedList comme usage général implémentations.

    Nous pouvons créer une Liste comme:

     List<String> arrayList = new ArrayList<>();
 List<String> linkedList = new LinkedList<>();

    Nous pouvons également créer une taille fixe de liste:

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

    Nous serait presque toujours à l'aide de ArrayList opposition à LinkedList mise en œuvre:

    1. LinkedList utilise beaucoup d'espace pour les objets et effectue mal lorsque nous avons beaucoup d'éléments.
    2. Indexées opération dans LinkedList nécessite O(n) le temps par rapport à O(1) dans ArrayList.
    3. Cochez cette lien pour plus d'informations.

    La liste créée par Arrays.asList ci-dessus ne peut pas être modifié structurellement, mais ses éléments peuvent encore être modifiés.

    Java 8

    Comme par doc, la méthode Collections.unmodifiableList retourne un inmodifiable vue de la liste spécifiée. Nous pouvons l'obtenir comme:

    Collections.unmodifiableList(Arrays.asList("A", "B", "C"));

    Java 9

    Au cas où nous utilisons Java 9 alors:

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

    Java 10

    Dans le cas où nous sommes à Java 10 puis la méthode de la Collectors.unmodifiableList renvoie une instance de vraiment inmodifiable liste introduites dans Java 9. Cochez cette réponse pour plus d'info à propos de la différence dans Collections.unmodifiableList vs Collectors.unmodifiableList dans Java 10.

    InformationsquelleAutor i_am_zero
  10. 9
    List list = new ArrayList();

    Ou avec les génériques

    List<String> list = new ArrayList<String>();

    Vous pouvez, bien sûr, remplacer chaîne avec n'importe quel type de variable: Entier, aussi.

    InformationsquelleAutor Paulo Guedes
  11. 8

    Parfois - mais très rarement - au lieu d'une nouvelle liste de tableaux, vous voulez un nouveau LinkedList. Commencer avec une liste de tableaux et si vous avez des problèmes de performance, et la preuve de la liste est le problème, et beaucoup de l'ajout et de la suppression de cette liste alors pas avant de passer à une LinkedList et de voir si les choses s'améliorent. Mais dans la main, le bâton avec ArrayList et tout ira bien.

    InformationsquelleAutor Carl Manaster
  12. 7

    Un exemple:

    List somelist = new ArrayList();

    Vous pouvez regarder le javadoc pour la Liste et trouver tous connu la mise en œuvre de classes de la List de l'interface qui sont inclus avec l'api java.

    InformationsquelleAutor Alex B
  13. 7

    À l'aide de Google Collections, vous pouvez utiliser les méthodes suivantes dans l' Listes classe

    import com.google.common.collect.Lists;

//...

List<String> strings = Lists.newArrayList();

List<Integer> integers = Lists.newLinkedList();

    Il y a des surcharges pour les varargs de l'initialisation et de l'initialisation à partir d'un Iterable<T>.

    L'avantage de ces méthodes est que vous n'avez pas besoin de spécifier le paramètre générique explicitement comme vous le feriez avec le constructeur - le compilateur déduit à partir du type de la variable.

    InformationsquelleAutor Ben Lings
  14. 6
    List<Object> nameOfList = new ArrayList<Object>();

    Vous avez besoin d'importer List et ArrayList.

    InformationsquelleAutor jp093121
  15. 6

    Avec Java 9, vous êtes en mesure d'effectuer les opérations suivantes pour créer un immuable List:

    List<Integer> immutableList = List.of(1, 2, 3, 4, 5);

List<Integer> mutableList = new ArrayList<>(immutableList);
    InformationsquelleAutor Jacob G.
  16. 5

    Il y a de nombreuses façons de créer un Ensemble et une Liste. HashSet et liste de tableaux ne sont que deux exemples. Il est également assez courant d'utiliser des génériques avec les collections de ces jours. Je vous suggère de jeter un oeil à ce qu'ils sont

    C'est une bonne introduction pour java builtin collections. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

    InformationsquelleAutor Peter Lawrey
  17. 5
    List arrList = new ArrayList();

    Il vaut mieux que vous utiliser des génériques comme indiqué ci-dessous:

    List<String> arrList = new ArrayList<String>();

arrList.add("one");

    Cas où vous utilisez LinkedList.

    List<String> lnkList = new LinkedList<String>();
    InformationsquelleAutor Rohit Goyal
  18. 5

    Plus d'options pour faire la même chose avec Java 8, pas mieux, pas pire, juste différent et si vous voulez faire un peu de travail supplémentaire avec les listes, Flux vous donnera plus de solutions de rechange (filtres, carte, réduire, etc.)

    List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());
List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());
List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());
LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));
    InformationsquelleAutor whyem
  19. 5

    Comme une option, vous pouvez utiliser la double accolade de l'initialisation ici:

    List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};
    • C'est une opération coûteuse. Vous êtes à la création d'un anonyme sous-classe de la liste de tableaux ici.
    • Je suis d'accord. C'est plus sur la syntaxe de sucre ici.
    InformationsquelleAutor angry_gopher
  20. 4

    À l'aide de Eclipse Collections vous pouvez créer une Liste comme ceci:

    List<String> list1 = Lists.mutable.empty();
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

    Si vous voulez une liste immuable: 

    ImmutableList<String> list3 = Lists.immutable.empty();
ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");

    Vous pouvez éviter l'auto-boxing par l'aide de primitives listes. Voici comment vous pouvez créer int listes:

    MutableIntList list5 = IntLists.mutable.empty();
MutableIntList list6 = IntLists.mutable.of(1, 2, 3);

ImmutableIntList list7 = IntLists.immutable.empty();
ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);

    Il y a des variantes pour tous les 8 primitives.

    MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);
MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);
MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);
MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);

    Remarque: je suis un committer pour Eclipse Collections.

    InformationsquelleAutor Craig P. Motlin
  21. 4

    Voici quelques façons que vous pouvez créer des listes.

    • Cela permettra de créer une liste de taille fixe, ajout/suppression de éléments n'est pas possible, il va jeter un java.lang.UnsupportedOperationException si vous essayez de le faire.

      List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});

    • La version suivante est une simple liste de où vous pouvez ajouter/supprimer n'importe quel nombre d'éléments.

      List<String> list = new ArrayList<>();

    • C'est la façon de créer un LinkedList en java, Si vous avez besoin de faire de fréquentes insertion/suppression d'éléments dans la liste, vous devez utiliser LinkedList au lieu de ArrayList

      List<String> linkedList = new LinkedList<>();
    InformationsquelleAutor Jobin Joseph
  22. 2

    Essayez ceci: 

    List<String> messages = Arrays.asList("bla1", "bla2", "bla3");

    Ou:

    List<String> list1 = Lists.mutable.empty(); //Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");
    InformationsquelleAutor Gavriel Cohen
  23. 2

    Si vous avez besoin d'un serializable, immuable liste avec une seule entité, vous pouvez utiliser:

    List<String> singList = Collections.singletonList("stackoverlow");
    InformationsquelleAutor erol yeniaras
  24. 0

    Comme une déclaration de tableau liste en java, c'est comme 

    public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

    Il y a de nombreuses façon, vous pouvez créer et initialiser la liste en java.

     1) List list = new ArrayList();

 2) List<type> myList = new ArrayList<>();

 3) List<type> myList = new ArrayList<type>();

 4) Using Utility class

    List<Integer> list = Arrays.asList(8, 4);
    Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

 5) Using static factory method

    List<Integer> immutableList = List.of(1, 2);


 6) Creation and initializing at a time

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});



 Again you can create different types of list. All has their own characteristics

 List a = new ArrayList();
 List b = new LinkedList();
 List c = new Vector(); 
 List d = new Stack(); 
 List e = new CopyOnWriteArrayList();
    InformationsquelleAutor Mak