java list how create
Ce didacticiel Java List explique comment créer, initialiser et imprimer des listes en Java. Le didacticiel explique également la liste des listes avec un exemple de code complet:
Ce didacticiel vous présentera la structure de données «liste» qui est l’une des structures de base de l’interface de collecte Java.
Une liste en Java est une séquence d'éléments selon un ordre. L'interface List du package java.util est celle qui implémente cette séquence d'objets classés d'une manière particulière appelée List.
=> Consultez TOUS les didacticiels Java ici.
Tout comme les tableaux, les éléments de la liste sont également accessibles en utilisant des index avec le premier index commençant à 0. L'index indique un élément particulier à l'index «i», c'est-à-dire qu'il est à i éléments du début de la liste.
Certaines des caractéristiques de la liste en Java incluent:
- Les listes peuvent avoir des éléments en double.
- La liste peut également contenir des éléments «nuls».
- Les listes prennent en charge les génériques, c'est-à-dire que vous pouvez avoir des listes génériques.
- Vous pouvez également avoir des objets mixtes (objets de différentes classes) dans la même liste.
- Les listes conservent toujours l'ordre d'insertion et autorisent l'accès positionnel.
Ce que vous apprendrez:
- Liste en Java
- Conclusion
Liste en Java
L'interface Java List est un sous-type de l'interface Java Collection. Il s'agit de l'interface standard qui hérite de l'interface Collection de Java.
Vous trouverez ci-dessous un diagramme de classes de l'interface Java List.
Comme indiqué dans le diagramme de classes ci-dessus, l'interface de liste Java s'étend de l'interface Collection du package java.util qui à son tour s'étend de l'interface Iterable du package java.util. La classe AbstractList fournit l'implémentation squelettique de l'interface List.
Les classes LinkedList, Stack, Vector, ArrayList et CopyOnWriteArrayList sont toutes les classes d'implémentation de l'interface List qui sont fréquemment utilisées par les programmeurs. Ainsi, il existe quatre types de listes en Java, à savoir Stack, LinkedList, ArrayList et Vector.
Par conséquent, lorsque vous devez implémenter une interface de liste, vous pouvez implémenter l'une des classes de type de liste ci-dessus en fonction des exigences. Pour inclure la fonctionnalité de l'interface de liste dans votre programme, vous devrez importez le package java.util. * qui contient l'interface de liste et d'autres définitions de classes comme suit:
import java.util.*;Créer et déclarer une liste
Nous avons déjà déclaré que List est une interface et est implémentée par des classes comme ArrayList, Stack, Vector et LinkedList. Par conséquent, vous pouvez déclarez et créez des instances de la liste de l'une des manières suivantes:
List linkedlist = new LinkedList(); List arrayList = new ArrayList(); List vec_list = new Vector(); List stck_list = new Stack(); Comme indiqué ci-dessus, vous pouvez créer une liste avec l'une des classes ci-dessus, puis initialiser ces listes avec des valeurs. À partir des instructions ci-dessus, vous pouvez voir que l'ordre des éléments changera en fonction de la classe utilisée pour créer une instance de la liste.
Par exemple, pour une liste avec classe de pile, l'ordre est Last In, First Out (LIFO).
Initialiser la liste Java
Vous pouvez utiliser l'une des méthodes ci-dessous pour initialiser un objet de liste.
# 1) Utilisation de la méthode asList
La méthode asList () est déjà traitée en détail dans la rubrique Arrays. Vous pouvez créer une liste immuable à l'aide des valeurs du tableau.
La syntaxe générale est:
List listname = Arrays.asList(array_name);Ici, le data_type doit correspondre à celui du tableau.
L'instruction ci-dessus crée une liste immuable. Si vous voulez que la liste soit modifiable, vous devez créer une instance de la liste à l'aide de new, puis lui affecter les éléments du tableau à l'aide de la méthode asList.
C'est comme indiqué ci-dessous:
List listname = new ArrayList (Arrays.asList(array_name));Soyons implémenter un programme en Java qui montre la création et l'initialisation de la liste à l'aide de la méthode asList .
différence entre les serveurs sql et sql
import java.util.*; public class Main { public static void main(String() args) { //array of strings String() strArray = {'Delhi', 'Mumbai', 'Kolkata', 'Chennai'}; //initialize an immutable list from array using asList method List mylist = Arrays.asList(strArray); //print the list System.out.println('Immutable list:'); for(String val : mylist){ System.out.print(val + ' '); } System.out.println('
'); //initialize a mutable list(arraylist) from array using asList method List arrayList = new ArrayList(Arrays.asList(strArray)); System.out.println('Mutable list:'); //add one more element to list arrayList.add('Pune'); //print the arraylist for(String val : arrayList){ System.out.print(val + ' '); } } Production:
Dans le programme ci-dessus, nous avons d'abord créé la liste immuable en utilisant la méthode asList. Ensuite, nous créons une liste modifiable en créant une instance de ArrayList, puis en initialisant cette ArrayList avec les valeurs du tableau à l'aide de la méthode asList.
Notez que comme la deuxième liste est modifiable, nous pouvons également y ajouter plus de valeurs.
# 2) Utilisation de List.add ()
Comme déjà mentionné, comme la liste n'est qu'une interface, elle ne peut pas être instanciée. Mais nous pouvons instancier des classes qui implémentent cette interface. Par conséquent, pour initialiser les classes de liste, vous pouvez utiliser leurs méthodes d'ajout respectives qui est une méthode d'interface de liste mais implémentée par chacune des classes.
Si vous instanciez une classe de liste liée comme ci-dessous:
List llist = new LinkedList ();Ensuite, pour ajouter un élément à une liste, vous pouvez utiliser la méthode add comme suit:
llist.add(3);Il existe également une technique appelée «Initialisation à double accolade» dans laquelle la liste est instanciée et initialisée en appelant la méthode add dans la même instruction.
Ceci est fait comme indiqué ci-dessous:
List llist = new LinkedList (){{ add(1); add(3);}};L'instruction ci-dessus ajoute les éléments 1 et 3 à la liste.
Le programme suivant montre le initialisations de la liste à l'aide de la méthode add . Il utilise également la technique d'initialisation à double accolade.
import java.util.*; public class Main { public static void main(String args()) { // ArrayList.add method List str_list = new ArrayList(); str_list.add('Java'); str_list.add('C++'); System.out.println('ArrayList : ' + str_list.toString()); // LinkedList.add method List even_list = new LinkedList(); even_list.add(2); even_list.add(4); System.out.println('LinkedList : ' + even_list.toString()); // double brace initialization - use add with declaration & initialization List num_stack = new Stack(){{ add(10);add(20); }}; System.out.println('Stack : ' + num_stack.toString()); } }Production:
Ce programme a trois déclarations de liste différentes, à savoir ArrayList, LinkedList et Stack.
Les objets ArrayList et LinkedList sont instanciés, puis les méthodes add sont appelées pour ajouter des éléments à ces objets. Pour la pile, l'initialisation à double accolade est utilisée dans laquelle la méthode add est appelée pendant l'instanciation elle-même.
# 3) Utilisation des méthodes de classe de collections
La classe collections de Java a diverses méthodes qui peuvent être utilisées pour initialiser la liste.
Certaines des méthodes sont:
- tout ajouter
La La syntaxe générale de la méthode addAll des collections est:
List listname = Collections.EMPTY_LIST; Collections.addAll(listname = new ArrayList(), values…); Ici, vous ajoutez des valeurs à une liste vide. La méthode addAll prend la liste comme premier paramètre suivi des valeurs à insérer dans la liste.
- unmodifiableList ()
La méthode ‘unmodifiableList ()’ renvoie une liste immuable à laquelle les éléments ne peuvent pas être ajoutés ni supprimés.
La syntaxe générale de cette méthode est la suivante:
List listname = Collections.unmodifiableList(Arrays.asList(values…));La méthode prend des valeurs de liste comme paramètres et renvoie une liste. Si vous essayez d'ajouter ou de supprimer un élément de cette liste, le compilateur lève une exception UnsupportedOperationException.
- singletonList ()
La méthode «singletonList» renvoie une liste contenant un seul élément. La liste est immuable.
La syntaxe générale de cette méthode est:
List listname = Collections.singletonList(value);Le programme Java suivant illustre les trois méthodes de la classe Collections discuté ci-dessus.
import java.util.*; public class Main { public static void main(String args()) { // empty list List list = new ArrayList(); // Instantiating list using Collections.addAll() Collections.addAll(list, 10, 20, 30, 40); // Print the list System.out.println('List with addAll() : ' + list.toString()); // Create& initialize the list using unmodifiableList method List intlist = Collections.unmodifiableList( Arrays.asList(1,3,5,7)); // Print the list System.out.println('List with unmodifiableList(): ' + intlist.toString()); // Create& initialize the list using singletonList method List strlist = Collections.singletonList('Java'); // Print the list System.out.println('List with singletonList(): ' + strlist.toString()); } }Production:
# 4) Utilisation des flux Java8
Avec l'introduction des flux dans Java 8, vous pouvez également créer un flux de données et les collecter dans une liste.
Le suivant programme montre la création d'une liste en utilisant stream.
import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; public class Main { public static void main(String args()) { // Creating a List using toList Collectors method List list1 = Stream.of('January', 'February', 'March', 'April', 'May') .collect(Collectors.toList()); // Print the list System.out.println('List from Java 8 stream: ' + list1.toString()); } }Production:
Le programme ci-dessus recueille le flux de chaîne dans une liste et le renvoie. Vous pouvez également utiliser les autres méthodes Collectors telles que «toCollection», «unmodifiableList», etc. en dehors de asList dans la fonction de collecte.
comment ouvrir les fichiers .torrent
# 5) Méthode Java 9 List.of ()
Une nouvelle méthode est introduite dans Java 9, List.of () qui prend n'importe quel nombre d'éléments et construit une liste. La liste construite est immuable.
import java.util.List; public class Main { public static void main(String args()) { // Create a list using List.of() List strList = List.of('Delhi', 'Mumbai', 'Kolkata'); // Print the List System.out.println('List using Java 9 List.of() : ' + strList.toString()); } }Production:
Exemple de liste
Vous trouverez ci-dessous un exemple complet d'utilisation d'une interface de liste et de ses différentes méthodes.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List intList = new ArrayList(); //add two values to the list intList.add(0, 10); intList.add(1, 20); System.out.println('The initial List:
' + intList); // Creating another list List cp_list = new ArrayList(); cp_list.add(30); cp_list.add(40); cp_list.add(50); // add list cp_list to intList from index 2 intList.addAll(2, cp_list); System.out.println('List after adding another list at index 2:
'+ intList); // Removes element from index 0 intList.remove(0); System.out.println('List after removing element at index 0:
' + intList); // Replace value of last element intList.set(3, 60); System.out.println('List after replacing the value of last element:
' + intList); } } Production:
La sortie du programme ci-dessus montre les différentes opérations effectuées sur une ArrayList. Tout d'abord, il crée et initialise la liste. Ensuite, il copie le contenu d'une autre liste dans cette liste et supprime également un élément de la liste. Enfin, il remplace le dernier élément de la liste par une autre valeur.
Nous explorerons les méthodes de liste en détail dans notre prochain tutoriel.
Liste d'impression
Il existe différentes méthodes permettant d'imprimer les éléments de la liste en Java.
Discutons de quelques-unes des méthodes ici.
# 1) Utilisation de la boucle For / Amélioration de la boucle For
La liste est une collection ordonnée accessible à l'aide d'index. Vous pouvez utiliser la boucle for qui est utilisée pour itérer en utilisant les index pour imprimer chaque élément de la liste.
Java a une autre version de la boucle for connue sous le nom de boucle for améliorée qui peut également être utilisée pour accéder et imprimer chaque élément de la liste.
Le programme Java illustré ci-dessous montre l'impression du contenu de la liste en utilisant la boucle for et la boucle for améliorée.
import java.util.List; import java.util.ArrayList; import java.util.Arrays; class Main{ public static void main (String() args) { //string list List list = Arrays.asList('Java', 'Python', 'C++', 'C', 'Ruby'); //print list using for loop System.out.println('List contents using for loop:'); for (int i = 0; i Production:
# 2) Utilisation de la méthode toString
La méthode «toString ()» de l'interface de liste renvoie la représentation sous forme de chaîne de la liste.
Le programme ci-dessous illustre l'utilisation de la méthode toString ().
import java.util.List; import java.util.ArrayList; class Main{ public static void main (String() args){ //initialize a string list List list = new ArrayList(){{add('Python');add('C++');add('Java');}}; // string representation of list using toString method System.out.println('List contents using toString() method:' + list.toString()); } } Production:
Liste convertie en matrice
La liste a une méthode toArray () qui convertit la liste en tableau. Une fois converti en tableau, vous pouvez utiliser les méthodes de tableau décrites dans la rubrique respective pour imprimer le contenu de ce tableau. Vous pouvez utiliser la boucle for ou améliorée for ou même la méthode toString.
L'exemple donné ci-dessous utilise la méthode toString pour imprimer le contenu du tableau.
import java.util.*; class Main { public static void main (String() args) { //list of odd numbers List oddlist = Arrays.asList(1,3,5,7,9,11); // using List.toArray() method System.out.println('Contents of list converted to Array:'); System.out.println(Arrays.toString(oddlist.toArray())); } } Production:
Utilisation des flux Java 8
Les flux sont introduits dans Java 8. Vous pouvez utiliser les flux pour parcourir la liste. Il existe également des lambdas à l'aide desquels vous pouvez parcourir la liste.
Le programme ci-dessous montre l'utilisation de flux pour parcourir la liste et afficher son contenu.
import java.util.*; class Main{ public static void main (String() args){ //list of even numbers List evenlist = Arrays.asList(2,4,6,8,10,12,14); // print list using streams System.out.println('Contents of evenlist using streams:'); evenlist.stream().forEach(S ->System.out.print(S + ' ')); } } Production:
Outre les méthodes décrites ci-dessus, vous pouvez utiliser des itérateurs de liste pour parcourir la liste et afficher son contenu. Nous aurons un article complet sur l'itérateur de liste dans les tutoriels suivants.
Liste des listes
L'interface de liste Java prend en charge la «liste des listes». En cela, les éléments individuels de la liste sont à nouveau une liste. Cela signifie que vous pouvez avoir une liste dans une autre liste.
Ce concept est très utile lorsque vous devez lire des données à partir de fichiers CSV, par exemple. Ici, vous devrez peut-être lire plusieurs listes ou listes à l'intérieur de listes, puis les stocker en mémoire. Encore une fois, vous devrez traiter ces données et réécrire dans le fichier. Ainsi, dans de telles situations, vous pouvez maintenir une liste de listes pour simplifier le traitement des données.
Le programme Java suivant illustre un exemple de liste Java de listes.
Dans ce programme, nous avons une liste de listes de type String. Nous créons deux listes distinctes de type chaîne et attribuons des valeurs à ces listes. Ces deux listes sont ajoutées à la liste des listes à l'aide de la méthode add.
Pour afficher le contenu de la liste des listes, nous utilisons deux boucles. La boucle externe (foreach) parcourt les listes de listes accédant aux listes. La boucle foreach interne accède aux éléments de chaîne individuels de chacune de ces listes.
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String() args) { //create list of lists List java_listOfLists = new ArrayList (); //create a language list and add elements to it ArrayList lang_list = new ArrayList(); lang_list.add('Java'); lang_list.add('C++'); //add language list to java list of list java_listOfLists.add(lang_list); //create a city list and add elements to it ArrayList city_list = new ArrayList(); city_list.add('Pune'); city_list.add('Mumbai'); //add the city list to java list of lists java_listOfLists.add(city_list); //display the contents of list of lists System.out.println('Java list of lists contents:'); java_listOfLists.forEach((list) -> //access each list { list.forEach((city)->System.out.print(city + ' ')); //each element of inner list }); } } Production:
La liste Java des listes est un petit concept mais est importante surtout lorsque vous devez lire des données complexes dans votre programme.
Questions fréquemment posées
Q # 1) Qu'est-ce qu'une liste et un ensemble en Java?
Répondre: Une liste est une collection ordonnée d'éléments. Vous pouvez avoir des éléments en double dans la liste.
Un ensemble n'est pas une collection ordonnée. Les éléments de l'ensemble ne sont pas organisés dans un ordre particulier. De plus, les éléments de l'ensemble doivent être uniques. Il n'autorise pas les doublons.
Q # 2) Comment fonctionne une liste en Java?
Répondre: La liste est une interface Java qui s'étend à partir de l'interface Collection. Les classes ArrayList, LinkedList, Stack et Vector implémentent l'interface de liste. Ainsi, un programmeur peut utiliser ces classes pour utiliser les fonctionnalités de l'interface de liste.
Q # 3) Qu'est-ce qu'une ArrayList en Java?
Répondre: ArrayList est un tableau dynamique. C'est une collection d'éléments redimensionnables et implémente l'interface de liste. ArrayList utilise en interne un tableau pour stocker les éléments.
Q # 4) Les listes commencent-elles à 0 ou 1 en Java?
Répondre: Les listes en Java ont un index entier de base zéro. Cela signifie que le premier élément de la liste est à l'index 0, le deuxième élément à l'index 1 et ainsi de suite.
Q # 5) La liste est-elle ordonnée?
Répondre: Oui. La liste est une collection ordonnée d'éléments. Cet ordre est conservé, lors de l'insertion d'un nouvel élément dans la liste,
Conclusion
Ce tutoriel a donné une introduction à l'interface de liste en Java. Nous avons également discuté des grands concepts de listes comme la création, l'initialisation des listes, l'impression de listes, etc.
Dans nos prochains tutoriels, nous discuterons des différentes méthodes fournies par l'interface de liste. Nous discuterons également de la construction d'itérateur utilisée pour itérer l'objet de liste. Nous discuterons de la conversion des objets de liste en d'autres structures de données dans notre prochain tutoriel.
=> Visitez ici pour voir la série de formations Java pour tous.
lecture recommandée
- Java Array - Déclarer, créer et initialiser un tableau en Java
- Tableau d'objets en Java: comment créer, initialiser et utiliser
- Java Hello World - Créez votre premier programme en Java aujourd'hui
- Déploiement Java: création et exécution d'un fichier JAR Java
- Machine virtuelle Java: comment JVM aide à exécuter une application Java
- Modificateurs d'accès en Java - Tutoriel avec des exemples
- Tutoriel de réflexion Java avec des exemples
- Introduction au langage de programmation Java - Tutoriel vidéo
