Comment faire une nouvelle liste en Java

De plus, si vous voulez créer une liste qui contient des choses (bien qu'elle soit de taille fixe):

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");

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

Liste immuable vide

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 des entiers

Ints.asList(1,2,3);                                             // Guava

En 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 une liste mutable non vide:

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

En Java 9

Utilisation d'une nouvelle List.of(...) statique usine méthodes:

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

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

En Java 10

Utilisation de l'inférence de type de variable locale :

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

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

var list3 = new ArrayList<String>();

Et suivre les meilleures pratiques...

Ne pas utiliser les types bruts

Depuis Java 5, les génériques ont fait partie du langage-vous devriez les utiliser:

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

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

Programme aux interfaces

Par exemple, programme à l'interface List:

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

Au lieu de:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!

, lisez d'Abord ce, alors lisez - ce et ce. 9 fois sur 10, vous utiliserez l'une de ces deux implémentations.

En fait, il suffit de lire Le Guide de Sun sur le cadre de collections.

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

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

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

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

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

Pour les listes immuables, vous pouvez utiliser la bibliothèque Guava:

List<String> list = ImmutableList.of("foo", "bar");

Liste est juste une interface comme Set.

Comme HashSet est une implémentation d'un ensemble qui a certaines propriétés en ce qui concerne les performances add / lookup / remove, ArrayList est l'implémentation nue d'une liste.

Si vous jetez un coup d'œil à la documentation des interfaces respectives, vous trouverez "Toutes les classes d'implémentation connues" et vous pourrez décider laquelle convient le mieux à vos besoins.

Il y a de fortes chances que ce soit ArrayList.

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 liste de taille fixe comme:

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

Nous utiliserions presque toujours ArrayList opposé à LinkedList implémentation:

1. LinkedList utilise beaucoup d'espace pour les objets et effectue mal lorsque nous avons beaucoup d'éléments.
2. Toute opération indexée dans LinkedList nécessite O (n) temps par rapport à O(1) dans ArrayList.
3. Vérifiez ce lien pour plus d'informations.

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

Java 8

Par doc, la méthode Collections.unmodifiableList renvoie 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 utiliserions Java 9 alors:

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

Java 10

Au cas où nous serions à Java 10 ensuite, la méthode Collectors.unmodifiableList retournera une instance de liste vraiment non modifiable introduite dans Java 9. Vérifiez cette réponse pour plus d'informations sur la différence entre Collections.unmodifiableList et Collectors.unmodifiableList dansJava 10 .

Parfois - mais très rarement - au lieu d'une nouvelle ArrayList, vous voudrez peut-être une nouvelle LinkedList. Commencez par ArrayList et si vous avez des problèmes de performances et des preuves que la liste est le problème, et beaucoup d'ajout et de suppression à cette liste - alors - pas avant - passez à une LinkedList et voyez si les choses s'améliorent. Mais dans l'ensemble, restez avec ArrayList et tout ira bien.

List list = new ArrayList();

Ou avec des génériques

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

Vous pouvez bien sûr remplacer string par n'importe quel type de variable, comme Integer.

Un exemple:

List somelist = new ArrayList();

Vous pouvez regarder le javadoc pour la liste et trouver toutes les classes d'implémentation connues de l'interface List qui sont incluses avec l'api java.

Utiliser 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 l'initialisation de varargs et l'initialisation à partir d'un Iterable<T>.

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

En option, vous pouvez utiliser l'initialisation double accolade ici:

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};

List<Object> nameOfList = new ArrayList<Object>();

, Vous devez importer List et ArrayList.

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 travail supplémentaire avec les listes, Streams vous fournira plus d'alternatives (filtrer, cartographier, 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));

Avec Java 9, vous pouvez faire ce qui suit pour créer un immuable List:

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

List<Integer> mutableList = new ArrayList<>(immutableList);

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

Ceci est une bonne introduction pour les collections intégrées de java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

List arrList = new ArrayList();

Il est préférable que vous utilisiez des génériques comme suggéré ci-dessous:

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

arrList.add("one");

Si vous utilisez LinkedList.

List<String> lnkList = new LinkedList<String>();

Voici quelques façons de créer des listes.

• Cela créera une liste avec une taille fixe, l'ajout/suppression d'éléments n'est pas possible, il lancera un java.lang.UnsupportedOperationException si vous essayez de le faire.

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

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

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

• Voici comment créer un LinkedList en java, Si vous avez besoin de faire fréquemment insertion/suppression d'éléments dans la liste, vous devez utiliser LinkedList au lieu de ArrayList

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

Utiliser 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 la boxe automatique en utilisant des listes primitives. Voici comment créer des listes int:

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 existe des variantes pour 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 les collections Eclipse.

Comme la déclaration de la liste de tableaux en java est comme

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

Il existe de nombreuses façons de créer et d'initialiser une liste de tableaux 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();

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

Si vous avez besoin d'une liste sérialisable et immuable avec une seule entité, vous pouvez utiliser:

List<String> singList = Collections.singletonList("stackoverlow");