Comment créer une nouvelle liste en Java

Nous créons un Setas:

Set myset = new HashSet()

Comment créer un Listen Java?

List myList = new ArrayList();

ou avec des génériques ( Java 7 ou version ultérieure)

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

ou avec des génériques (anciennes versions java)

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

De plus, si vous souhaitez créer une liste contenant des éléments (même si sa taille sera 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 des personnages

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

Liste des entiers

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

Dans Java 8

Pour créer une liste non vide de taille fixe (les opérations telles que l'ajout, la suppression, etc. ne sont pas prises 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));

Dans Java 9

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

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

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

Dans Java 10

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

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

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

var list3 = new ArrayList<String>();

Et suivez les meilleures pratiques ...

N'utilisez pas de types bruts

Depuis Java 5, les génériques font partie du langage - vous devez 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, programmez l' Listinterface:

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

Au lieu de:

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

Lisez d'abord ceci , puis lisez ceci et ceci . 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 framework 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 une inférence de type pour la création d'instances génériques , 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:

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

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

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

La liste n'est qu'une interface comme Set .

Comme HashSet est une implémentation d'un ensemble qui possède certaines propriétés en ce qui concerne les performances d'ajout / recherche / suppression, ArrayList est l'implémentation nue d'une liste.

Si vous jetez un œil à la documentation des interfaces respectives, vous trouverez "Toutes les classes d'implémentation connues" et vous pourrez décider laquelle est la plus adaptée à vos besoins.

Il y a de fortes chances que ce soit ArrayList .

Listest une interface comme Setet a ArrayListet LinkedListcomme implémentations à usage général .

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 ArrayListplutôt que la LinkedListmise en œuvre:

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

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

Java 8

Selon le document , la méthode Collections.unmodifiableListrenvoie une vue non modifiable de la liste spécifiée. Nous pouvons l'obtenir comme:

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

Java 9

Dans le cas où nous utilisons Java 9, alors:

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

Java 10

Dans le cas où nous en sommes à Java 10, la méthode Collectors.unmodifiableListretournera 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 vs Collectors.unmodifiableListet Java 10 .

Parfois - mais très rarement - au lieu d'une nouvelle ArrayList, vous pouvez souhaiter une nouvelle LinkedList. Commencez avec ArrayList et si vous avez des problèmes de performances et des preuves que la liste est le problème, et que vous ajoutez et supprimez beaucoup à 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 la chaîne par n'importe quel type de variable, comme Integer, également.

Un exemple:

List somelist = new ArrayList();

Vous pouvez consulter le javadoc pour List et trouver toutes les classes d'implémentation connues de l' Listinterface qui sont incluses avec l'API Java.

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

import com.google.common.collect.Lists;

// ...

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

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

Il existe des surcharges pour l'initialisation des 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 le déduira du type de la variable.

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

Vous devez importer Listet 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, mapper, 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 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);

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

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

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 de nos jours. Je vous suggère de voir ce qu'ils sont

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

List arrList = new ArrayList();

Il vaut mieux utiliser des génériques comme suggéré ci-dessous:

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

arrList.add("one");

Dans le cas où vous utilisez LinkedList.

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

À l'aide des collections Eclipse, vous pouvez créer une liste comme celle-ci:

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.

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

• Cela créera une liste de taille fixe, l' ajout / la suppression d' éléments n'est pas possible, il lancera un java.lang.UnsupportedOperationExceptionsi 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 un nombre illimité d'éléments.

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

• Voici comment créer un LinkedListen Java, Si vous devez faire l' insertion fréquente / suppression d'éléments sur la liste, vous devez utiliser au LinkedListlieu deArrayList

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

Essaye ça:

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

Comme la déclaration de la liste des 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();