Comment créer une nouvelle liste dans Java
Nous créons une Set comme:
Set myset = new HashSet()
Comment crée-t-on une List en Java?
List myList = new ArrayList();
ou avec des génériques ( Java 7 ou ultérieure)
List<MyType> myList = new ArrayList<>();
ou avec des génériques (Anciennes versions Java)
List<MyType> myList = new ArrayList<MyType>();
En outre, si vous souhaitez créer une liste contenant des éléments (même si sa taille est fixe):
List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");
Laissez-moi résumer et ajouter quelque chose:
1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")
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 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
Dans Java 8
Pour créer une liste non vide de taille fixe (les opérations comme ajouter, supprimer, 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éthodes d'usine statiques:
List<Integer> immutableList = List.of(1, 2);
List<Integer> mutableList = new ArrayList<>(List.of(3, 4));
Dans Java 10
Utilisation de 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 suivez les meilleures pratiques ...
ne pas utiliser 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’interface List:
List<Double> list = new ArrayList<>();
Au lieu de:
ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!
Commencez par lire this , puis lisez this et this . 9 fois sur 10, vous utiliserez l'une de ces deux implémentations.
En fait, il suffit de lire Guide de Sun pour le framework 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 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 du 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");
List est juste une interface comme Set .
Comme HashSet est une implémentation d'un ensemble qui possède certaines propriétés en ce qui concerne l'ajout/la recherche/la suppression de performances, ArrayList est l'implémentation nue d'une liste.
Si vous consultez la documentation des interfaces respectives, vous trouverez "Toutes les classes d'implémentation connues" et vous pourrez choisir celle qui convient le mieux à vos besoins.
Les chances sont que c'est ArrayList .
List est une interface comme Set et a ArrayList et LinkedList comme implémentations à usage général .
Nous pouvons créer une liste en tant que:
List<String> arrayList = new ArrayList<>();
List<String> linkedList = new LinkedList<>();
Nous pouvons également créer une liste de taille fixe en tant que:
List<String> list = Arrays.asList("A", "B", "C");
Nous utiliserions presque toujours ArrayList contrairement à LinkedList implementation:
LinkedListutilise beaucoup d'espace pour les objets et fonctionne mal lorsque nous avons beaucoup d'éléments.- Toute opération indexée dans
LinkedListnécessite O(n) fois comparée à O(1) dansArrayList. - Cochez cette 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
Conformément à doc , la méthode Collections.unmodifiableList renvoie une vue non modifiable de la liste spécifiée. Nous pouvons l'obtenir comme:
Collections.unmodifiableList(Arrays.asList("A", "B", "C"));
Java 9
Si nous utilisons Java 9 , alors:
List<String> list = List.of("A", "B");
Java 10
Si nous sommes à Java 10, la méthode Collectors.unmodifiableList renverra une instance de liste réellement non modifiable introduite dans Java 9. Cochez answer pour plus d'informations sur la différence entre Collections.unmodifiableList et Collectors.unmodifiableList dans Java 10 .
List list = new ArrayList();
Ou avec des génériques
List<String> list = new ArrayList<String>();
Vous pouvez bien sûr remplacer chaîne par n’importe quel type de variable, tel que Integer.
Parfois - mais très rarement - à la place d'une nouvelle ArrayList, vous voudrez peut-être une nouvelle LinkedList. Commencez par ArrayList. Si vous rencontrez des problèmes de performances et que vous constatez que la liste est le problème, ajoutez-en de nombreuses autres et supprimez-les - puis pas avant - passez à la liste LinkedList et vérifiez si les choses s'améliorent. Mais dans l’ensemble, restez avec ArrayList et tout ira bien.
En utilisant Google Collections , vous pouvez utiliser les méthodes suivantes dans la classe Listes
import com.google.common.collect.Lists;
// ...
List<String> strings = Lists.newArrayList();
List<Integer> integers = Lists.newLinkedList();
Il existe des surcharges pour l'initialisation et l'initialisation de varargs à partir d'un Iterable<T>.
L'avantage de ces méthodes est qu'il n'est pas nécessaire 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.
Un exemple:
List somelist = new ArrayList();
Vous pouvez consulter javadoc for List et rechercher toutes les classes d'implémentation connues de l'interface List qui sont incluses dans l'api Java.
List<Object> nameOfList = new ArrayList<Object>();
Vous devez importer List et ArrayList.
Avec Java 9, vous pouvez procéder comme suit pour créer un immuableList:
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");
}
};
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 en fournira plus 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));
Il existe plusieurs 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 regarder ce qu'ils sont
C'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 vaut mieux utiliser 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 de taille fixe, ajouter/supprimer éléments n'est pas possible, cela jettera un
Java.lang.UnsupportedOperationExceptionsi vous essayez de le faire.List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});
La version suivante est une simple liste dans laquelle vous pouvez ajouter/supprimer n’importe quel nombre d’éléments.
List<String> list = new ArrayList<>();
Voici comment créer un
LinkedListen Java. Si vous devez insérer/supprimer fréquemment des éléments de la liste, vous devez utiliserLinkedListau lieu deArrayList.List<String> linkedList = new LinkedList<>();
En utilisant Eclipse Collections , 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 partisan des collections Eclipse.
Si vous avez besoin d’une liste sérialisable et immuable avec une seule entité, vous pouvez utiliser:
List<String> singList = Collections.singletonList("stackoverlow");
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");
Comme la déclaration de la liste de tableaux dans Java est comme
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
Il existe de nombreuses manières 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();