java arraylist conversions other collections
Ce didacticiel traite des conversions de ArrayList vers d'autres collections telles que Set, LinkedList, Lists, etc. ainsi que des différences entre ces collections:
Jusqu'à présent, nous avons vu presque tous les concepts liés à ArrayList en Java. Outre la création et la manipulation d'ArrayList à l'aide de diverses opérations ou méthodes fournies par la classe ArrayList, il est parfois également nécessaire de convertir ArrayList en une ou plusieurs collections.
=> Visitez ici pour apprendre Java à partir de zéro.
Dans ce didacticiel, nous discuterons de certaines des conversions entre ArrayList et d'autres collections qui incluent List, LinkedList, Vector, Set, etc. Après les conversions, nous discuterons également des différences entre ArrayLists et d'autres collections - Arrays, List, Vector, LinkedList, etc.
Ce que vous apprendrez:
- Conversion de ArrayList en chaîne
- Conversion de chaîne en ArrayList
- Convertir la liste en ArrayList en Java
- Convertir ArrayList à définir en Java
- Convertir l'ensemble en ArrayList en Java
- Un tableau de ArrayList en Java
- ArrayList of Arrays en Java
- List Vs ArrayList en Java
- Vector Vs ArrayList
- ArrayList vs LinkedList
- Questions fréquemment posées
- Conclusion
- lecture recommandée
Conversion de ArrayList en chaîne
Les méthodes suivantes peuvent être utilisées pour convertir ArrayList en String.
# 1) Utilisation d'un objet StringBuilder
import java.util.ArrayList; public class Main { public static void main(String args()) { //Create and initialize the ArrayList ArrayList strList = new ArrayList(); strList.add('Software'); strList.add('Testing'); strList.add('Help'); //print the ArrayList System.out.println('The ArrayList: ' + strList); //define a stringbuilder object StringBuffer sb = new StringBuffer(); //append each ArrayList element to the stringbuilder object for (String str : strList) { sb.append(str + ' '); } //convert stringbuilder to string and print it. String myStr = sb.toString(); System.out.println('
String from ArrayList: ' + myStr); } } Production:
ArrayList: (Logiciel, test, aide)
Chaîne de ArrayList: Aide sur les tests de logiciels
Dans le programme ci-dessus, un objet StringBuilder est créé. Ensuite, à l'aide de la boucle forEach, chaque élément de ArrayList est ajouté à l'objet StringBuilder. Ensuite, l'objet StringBuilder est converti en chaîne. Notez que l'utilisation de la méthode StringBuilder «append»; vous pouvez également ajouter un délimiteur approprié à la chaîne.
Dans l'exemple ci-dessus, nous avons utilisé l'espace («») comme délimiteur.
# 2) Utilisation de la méthode String.join ()
La méthode String.join () peut être utilisée pour convertir ArrayList en String. Ici, vous pouvez également passer le délimiteur approprié à la méthode de jointure.
Le programme ci-dessous le démontre.
import java.util.ArrayList; public class Main { public static void main(String() args) { // create and initialize the ArrayList ArrayList metroList = new ArrayList(); metroList.add('Delhi'); metroList.add('Mumbai'); metroList.add('Chennai'); metroList.add('Kolkata'); //print the ArrayList System.out.println('The ArrayList: ' + metroList); // Join with an empty delimiter to concat all strings. String resultStr = String.join(' ', metroList); System.out.println('
String converted from ArrayList: '+resultStr); } }Production:
The ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
Chaîne convertie à partir de ArrayList: Delhi Mumbai Chennai Kolkata
Vous pouvez voir que nous transmettons directement ArrayList comme argument à la méthode String.join () avec le délimiteur.
Pour les ArrayLists String simples, String.join () est la meilleure méthode pour convertir en String. Mais pour les objets ArrayLists plus complexes, l'utilisation de StringBuilder est plus efficace.
Conversion de chaîne en ArrayList
Afin de convertir une chaîne en ArrayList, il y a deux étapes:
- La chaîne est divisée à l'aide de la fonction split () et les sous-chaînes (divisées sur le délimiteur approprié) sont stockées dans un tableau de chaînes.
- Le tableau de chaînes obtenu en divisant la chaîne est ensuite converti en ArrayList à l’aide de la méthode ‘asList ()’ de la classe Arrays.
Le programme pour convertir la chaîne en ArrayList est donné ci-dessous.
import java.util.ArrayList; import java.util.List; import java.util.Arrays; public class Main { public static void main(String args()){ //define a string String myStr = 'The string to ArrayList program'; //convert string to array using split function on spaces String strArray() = myStr.split(' '); //print the string System.out.println('The input string : ' + myStr); //declare an ArrayList List strList = new ArrayList(); //convert string array to ArrayList using asList method strList = Arrays.asList(strArray); //print the resultant ArrayList System.out.println('
The ArrayList from String:' + strList ); } } Production:
La chaîne d'entrée: la chaîne du programme ArrayList
ArrayList de String: (The, string, to, ArrayList, program)
Dans le programme ci-dessus, nous divisons la chaîne en espaces et la collectons dans un tableau de chaînes. Ce tableau est ensuite converti en un ArrayList de chaînes.
Convertir la liste en ArrayList en Java
ArrayList implémente l'interface List. Si vous souhaitez convertir une liste en son implémentation comme ArrayList, vous pouvez le faire en utilisant la méthode addAll de l'interface List.
Le programme ci-dessous montre la conversion de la liste en ArrayList en ajoutant tous les éléments de la liste à ArrayList.
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String a()){ //create a list & initiliaze it List collections_List = new ArrayList(); collections_List.add('ArrayList'); collections_List.add('Vector'); collections_List.add('LinkedList'); collections_List.add('Stack'); collections_List.add('Set'); collections_List.add('Map'); //print the list System.out.println('List contents: '+collections_List); //create an ArrayList ArrayList myList = new ArrayList(); //use addAll() method to add list elements to ArrayList myList.addAll(collections_List); //print the ArrayList System.out.println('
ArrayList after adding elements: '+myList); } } Production:
Contenu de la liste: (ArrayList, Vector, LinkedList, Stack, Set, Map)
ArrayList après l'ajout d'éléments: (ArrayList, Vector, LinkedList, Stack, Set, Map)
Convertir ArrayList à définir en Java
Les méthodes suivantes convertissent une ArrayList en Set.
# 1) Utiliser une approche itérative traditionnelle
C'est l'approche traditionnelle. Ici, nous parcourons la liste et ajoutons chaque élément de ArrayList à l'ensemble.
Dans le programme ci-dessous, nous avons une ArrayList de chaîne. Nous déclarons un HashSet de chaîne. Ensuite, en utilisant la boucle forEach, nous itérons sur ArrayList et ajoutons chaque élément au HashSet.
De la même manière, nous pouvons également convertir ArrayList en treeSet.
import java.util.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); //Declare a HashSet Set hSet = new HashSet(); //Add each ArrayList element to the set for (String x : colorsList) hSet.add(x); //Print the HashSet System.out.println('
HashSet obtained from ArrayList: ' + hSet); } } Production:
The ArrayList: (Rouge, Vert, Bleu, Cyan, Magenta, Jaune)
HashSet obtenu à partir de ArrayList: (Rouge, Cyan, Bleu, Jaune, Magenta, Vert)
# 2) Utilisation de Set Constructor
La méthode suivante pour convertir une ArrayList en un ensemble utilise le constructeur. Dans cette méthode, nous transmettons ArrayList en tant qu'argument au constructeur d'ensemble et initialisons ainsi l'objet d'ensemble avec des éléments ArrayList.
Exemple de tri à bulles C ++
Le programme ci-dessous montre l'utilisation de ArrayList dans la création d'un objet set.
import java.util.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); //Declare a TreeSet Set tSet = new TreeSet(colorsList); //Print the TreeSet System.out.println('
TreeSet obtained from ArrayList: ' + tSet); } } Production:
The ArrayList: (Rouge, Vert, Bleu, Cyan, Magenta, Jaune
TreeSet obtenu à partir de ArrayList: (Bleu, Cyan, Vert, Magenta, Rouge, Jaune)
# 3) Utilisation de la méthode addAll
Vous pouvez également utiliser la méthode addAll de Set pour ajouter tous les éléments de ArrayList à l'ensemble.
Le programme suivant utilise la méthode addAll pour ajouter les éléments de ArrayList au HashSet.
import java.util.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); //Declare a HashSet Set hSet = new HashSet(); //use addAll method of HashSet to add elements of ArrayList hSet.addAll(colorsList); //Print the HashSet System.out.println('
HashSet obtained from ArrayList: ' + hSet); } } Production:
The ArrayList: (Rouge, Vert, Bleu, Cyan, Magenta, Jaune)
HashSet obtenu à partir de ArrayList: (Rouge, Cyan, Bleu, Jaune, Magenta, Vert)
# 4) Utilisation de Java 8 Stream
Les flux sont les nouveaux ajouts à Java 8. Cette classe de flux fournit une méthode pour convertir ArrayList en flux, puis pour définir.
Le programme Java ci-dessous illustre l'utilisation de la méthode de classe de flux pour convertir ArrayList en set.
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); // Convert ArrayList to set using stream Set set = colorsList.stream().collect(Collectors.toSet()); //Print the Set System.out.println('
Set obtained from ArrayList: ' + set); } } Production:
The ArrayList: (Rouge, Vert, Bleu, Cyan, Magenta, Jaune)
Ensemble obtenu à partir de ArrayList: (Rouge, Cyan, Bleu, Jaune, Magenta, Vert)
Convertir l'ensemble en ArrayList en Java
Dans la dernière section, nous avons vu la conversion de ArrayList en Set. La conversion de Set à ArrayList utilise également les mêmes méthodes que celles décrites ci-dessus, à la différence que la position de l'ensemble et ArrayList change.
Vous trouverez ci-dessous des exemples de programmation pour convertir Set en ArrayList. L'autre description de chaque méthode reste la même.
# 1) Approche itérative
import java.util.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList ArrayList numList = new ArrayList(set.size()); //add each set element to the ArrayList using add method for (String str : set) numList.add(str); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Production:
L'ensemble donné: (un, deux, trois)
ArrayList obtenue à partir de l'ensemble: (One, Two, Three)
Dans le programme ci-dessus, nous parcourons l'ensemble et chaque élément d'ensemble est ajouté à ArrayList.
# 2) Utilisation du constructeur
import java.util.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList and pass set to the constructor List numList = new ArrayList(set); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Production:
L'ensemble donné: (un, deux, trois)
ArrayList obtenue à partir de l'ensemble: (One, Two, Three)
Le programme ci-dessus crée un ensemble et une ArrayList. L'objet ArrayList est créé en fournissant un objet set comme argument dans son constructeur.
# 3) Utilisation de la méthode addAll
import java.util.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList List numList = new ArrayList(); //use addAll method of ArrayList to add elements of set numList.addAll(set); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Production:
L'ensemble donné: (un, deux, trois)
ArrayList obtenue à partir de l'ensemble: (One, Two, Three)
Ici, nous utilisons la méthode addAll de ArrayList pour ajouter les éléments de l'ensemble à ArrayList.
# 4) Utilisation de Java 8 Stream
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList and using stream method,assign stream of elements to ArrayList List numList = set.stream().collect(Collectors.toList()); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Production:
L'ensemble donné: (un, deux, trois)
ArrayList obtenue à partir de l'ensemble: (One, Two, Three)
Le programme ci-dessus utilise la classe de flux pour convertir Set en ArrayList.
Un tableau de ArrayList en Java
Un Array of ArrayList comme son nom l'indique se compose de ArrayLists en tant qu'éléments. Bien que la fonctionnalité ne soit pas utilisée régulièrement, elle est utilisée lorsqu'une utilisation efficace de l'espace mémoire est une exigence.
Le programme suivant implémente un tableau de ArrayLists en Java.
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String() args) { //define and initialize a num_list List num_list = new ArrayList(); num_list.add('One'); num_list.add('Two'); num_list.add('Two'); //define and initialize a colors_list List colors_list = new ArrayList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); //define Array of ArrayList with two elements List() arrayOfArrayList = new List(2); //add num_list as first element arrayOfArrayList(0) = num_list; //add colors_list as second element arrayOfArrayList(1) = colors_list; //print the contents of Array of ArrayList System.out.println('Contents of Array of ArrayList:'); for (int i = 0; i Production:
Contenu de Array of ArrayList:
(Un, deux, deux)
(Rouge, vert, bleu)
Dans le programme ci-dessus, nous définissons d'abord deux listes. Ensuite, nous déclarons un tableau de deux ArrayList. Chaque élément de ce tableau est la ArrayList définie précédemment. Enfin, le contenu d'un Array of ArrayList est affiché à l'aide d'une boucle for.
ArrayList of Arrays en Java
Tout comme nous avons un Array of ArrayLists, nous pouvons également avoir ArrayList of Arrays. Ici, chaque élément individuel d'un ArrayList est un Array.
Le programme ci-dessous montre ArrayList of Arrays.
import java.util.*; public class Main { public static void main(String() args) { // declare ArrayList of String arrays ArrayList ArrayList_Of_Arrays = new ArrayList(); //define individual string arrays String() colors = { 'Red', 'Green', 'Blue' }; String() cities = { 'Pune', 'Mumbai', 'Delhi'}; //add each array as element to ArrayList ArrayList_Of_Arrays.add(colors); ArrayList_Of_Arrays.add(cities); // print ArrayList of Arrays System.out.println('Contents of ArrayList of Arrays:'); for (String() strArr : ArrayList_Of_Arrays) { System.out.println(Arrays.toString(strArr)); } } } Production:
Contenu de ArrayList of Arrays:
(Rouge, vert, bleu)
(Pune, Mumbai, Delhi)
Le programme ci-dessus montre ArrayList of Arrays. Au départ, nous déclarons un ArrayList de String Arrays. Cela signifie que chaque élément de ArrayList sera un tableau de chaînes. Ensuite, nous définissons deux tableaux de chaînes. Ensuite, chacun des tableaux est ajouté à ArrayList. Enfin, nous imprimons le contenu de ArrayList of Arrays.
Pour imprimer le contenu, nous parcourons la ArrayList en utilisant la boucle for. Pour chaque itération, nous imprimons le contenu de l'élément ArrayList qui a un Array en utilisant la méthode Arrays.toString ().
List Vs ArrayList en Java
Les tableaux suivants présentent certaines des différences entre une List et une ArrayList.
liste Liste des tableaux La liste est une interface en Java ArrayList fait partie du framework Java Collection La liste est implémentée comme une interface ArrayList est implémenté en tant que classe de collection Étend l'interface de collecte implémente l'interface List et étend AbstractList Partie de l'espace de noms System.Collection.generic Partie de l'espace de noms System.Collections À l'aide de List, une liste d'éléments peut être créée, accessible à l'aide d'indices. En utilisant ArrayList, nous pouvons créer un tableau dynamique d'éléments ou d'objets dont la taille change automatiquement avec les changements de contenu.
Vector Vs ArrayList
Vous trouverez ci-dessous quelques-unes des différences entre un vecteur et un ArrayList.
Liste des tableaux LinkedList ArrayList implémente l'interface de liste LinkedList implémente les interfaces List et Deque. Le stockage et l'accès aux données sont efficaces dans ArrayList. LinkedList est bon pour manipuler les données. ArrayList implémente en interne un tableau dynamique. LinkedList implémente en interne une liste doublement liée. Étant donné qu'ArrayList implémente en interne un tableau dynamique, l'ajout / la suppression d'éléments est lent car beaucoup de décalage de bits est nécessaire. LinkedList est plus rapide en ce qui concerne l'ajout / la suppression d'éléments car aucun décalage de bits n'est nécessaire. Moins de surcharge de mémoire car dans ArrayList, seules les données réelles sont stockées. Plus de surcharge de mémoire puisque chaque nœud de LinkedList contient des données ainsi que l'adresse du nœud suivant.
ArrayList vs LinkedList
Voyons maintenant les différentes différences entre une ArrayList et une LinkedList.
Liste des tableaux LinkedList ArrayList implémente l'interface de liste LinkedList implémente les interfaces List et Deque. Le stockage et l'accès aux données sont efficaces dans ArrayList. LinkedList est bon pour manipuler les données. ArrayList implémente en interne un tableau dynamique. LinkedList implémente en interne une liste doublement liée. Étant donné qu'ArrayList implémente en interne un tableau dynamique, l'ajout / la suppression d'éléments est lent car beaucoup de décalage de bits est nécessaire. LinkedList est plus rapide en ce qui concerne l'ajout / la suppression d'éléments car aucun décalage de bits n'est nécessaire. Moins de surcharge de mémoire car dans ArrayList, seules les données réelles sont stockées. Plus de surcharge de mémoire puisque chaque nœud de LinkedList contient des données ainsi que l'adresse du nœud suivant.
Questions fréquemment posées
Q # 1) Comment convertir une ArrayList en Array en Java?
Répondre: Pour convertir une ArrayList en Array en Java, on peut utiliser la méthode toArray () de l'API ArrayList qui convertit une ArrayList donnée en Array.
Q # 2) Comment diviser une chaîne et la stocker dans une ArrayList en Java?
Répondre: La chaîne est divisée à l'aide d'une fonction split (). Cette méthode renvoie un tableau de chaînes. Ensuite, à l'aide de la méthode Arrays.asList (), le tableau de chaînes peut être converti en ArrayList de chaînes.
fonction sleep en c ++
Q # 3) Quelle est la taille par défaut d'une ArrayList?
Répondre: Un objet ArrayList créé sans spécifier la capacité a une taille 0 car il n'y a aucun élément ajouté à la liste. Mais la capacité par défaut de cette ArrayList est de 10.
Q # 4) Quelle est la différence entre length () et size () de ArrayList?
Répondre: Un ArrayList n'a pas de propriété ou de méthode length (). Il fournit uniquement la méthode size () qui renvoie le nombre total d'éléments dans ArrayList.
Q # 5) Quelle est la différence entre la capacité et la taille de ArrayList?
Répondre: ArrayList possède à la fois la capacité et la taille. La capacité correspond à la taille totale de la ArrayList ou au nombre total d'éléments qu'elle peut contenir. La taille est le nombre d'éléments ou d'emplacements contenant des données.
Par exemple, si la capacité d'ArrayList est de 10 et sa taille de 5, cela signifie qu'une ArrayList peut contenir jusqu'à 10 éléments, mais à l'heure actuelle, seuls 5 emplacements contiennent des données.
Conclusion
Dans ce didacticiel, nous avons discuté de certains des concepts supplémentaires liés à ArrayList, tels que la conversion d'ArrayList en une chaîne, une liste, un ensemble et vice versa. Nous avons également discuté des différences entre ArrayList et Vector, ArrayList et LinkedList, etc.
Dans notre prochain tutoriel, nous allons prendre une autre collection et l'apprendre en profondeur.
=> Cliquez ici pour voir de A à Z des didacticiels de formation Java ici.
lecture recommandée
- Tutoriel Java String with String Buffer et String Builder
- Java ArrayList - Comment déclarer, initialiser et imprimer une ArrayList
- Tutoriel de réflexion Java avec des exemples
- Tutoriel Java String | Méthodes de chaîne Java avec exemples
- Threads Java avec méthodes et cycle de vie
- Déploiement Java: création et exécution d'un fichier JAR Java
- Principes de base de Java: syntaxe Java, classe Java et principaux concepts Java
- Machine virtuelle Java: comment JVM aide à exécuter une application Java
