Menu

Liste secrète pour tableau et autres collections en Java

  • Principal
  • Autre
  • Liste secrète pour tableau et autres collections en Java

covert list array

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel explique comment convertir une liste Java en tableau et autres collections. Il comprend des exemples pour convertir une liste en tableau, chaîne, ensemble et vice-versa:

Dans nos didacticiels précédents, nous avons discuté des détails de la collection de listes. Nous avons vu les différentes opérations sur la liste, les itérateurs, etc. Étant donné une liste, nous pouvons convertir cette liste en toutes autres collections ou structures de données comme des chaînes, des tableaux, ArrayList, set, etc.

=> Visitez ici pour la série exclusive de didacticiels de formation Java.

Convertir la liste Java en tableau et autres collections

Ce que vous apprendrez:

Répertorier les conversions

Ici, ce que nous faisons réellement, c'est que nous transférons les éléments d'une collection / structure à une autre et, ce faisant, nous changeons en fait la disposition des éléments car chaque collection ou structure de données a sa propre disposition.

Dans ce tutoriel, nous aborderons quelques conversions de la liste vers d'autres structures de données et vice-versa.

Convertir la liste en chaîne

Vous pouvez facilement convertir la liste des éléments en sa représentation sous forme de chaîne. La plupart du temps, vous souhaiterez convertir une liste de chaînes ou de caractères en une représentation sous forme de chaîne.

Il existe différentes méthodes pour convertir la liste en chaîne. Les plus populaires sont discutés ci-dessous.

# 1) Utilisation de la méthode toString

C'est la méthode la plus simple pour convertir une liste en chaîne. Dans cette méthode, vous utilisez simplement la méthode «toString» sur une liste qui convertit la liste en une représentation sous forme de chaîne.

Le programme ci-dessous montre l'implémentation de la méthode toString.

import java.util.Arrays; import java.util.List; // Convert List of Characters to String in Java class Main { public static void main(String() args) { // create and initialize a character list List strList = Arrays.asList('H', 'e', 'l', 'l', 'o'); //convert list to string using toString method System.out.println('List converted to string representation: ' + strList.toString()); //replace comma between characters with blanks String string = strList.toString() .substring(1, 3 * strList.size() - 1) .replaceAll(', ', ''); // print string System.out.println('String representation by removing delimiters: ' + string); } }

Production:

Utilisation de la méthode toString - Sortie

Dans ce programme, vous pouvez voir qu'après avoir converti la liste de caractères en une représentation sous forme de chaîne, la chaîne est affinée davantage en supprimant les caractères de délimitation et en la représentant comme un mot unique.

# 2) Utilisation de la classe des collectionneurs

À partir de Java 8, vous pouvez utiliser des API de flux avec la classe «Collectors» pour convertir la liste en chaîne.

Exemple:

import java.util.stream.Collectors; import java.util.Arrays; import java.util.List; class Main { public static void main(String() args) { // create and initialize list List strList = Arrays.asList('W', 'o', 'r', 'l','d'); // convert list to string using collect and joining() method String string= strList.stream().map(String::valueOf).collect(Collectors.joining()); // print string System.out.println('List converted to string:' + string); } }

Production:

Utilisation de la classe Collectors

Dans le programme ci-dessus, nous utilisons les API de flux, mappons les valeurs, puis utilisons la méthode join () de la classe Collectors, et convertissons la liste en chaîne.

# 3) Utilisation de la classe StringBuilder

La troisième méthode de conversion de la liste en chaîne consiste à utiliser un objet StringBuilder. Ici, chaque élément de la liste est ajouté à l'objet StringBuilder à l'aide d'une boucle. Ensuite, l'objet StringBuilder est converti en sa représentation sous forme de chaîne à l'aide de la méthode toString.

Vérifiez le programme suivant pour la démonstration.

import java.util.Arrays; import java.util.List; class Main { public static void main(String() args) { // create and initialize the list List strList = Arrays.asList('I', 'n', 'd', 'i', 'a'); // object of stringBuilder StringBuilder sb = new StringBuilder(); // use append method to append list element to StringBuilder object for (Character ch : strList) { sb.append(ch); } // convert StringBuilder object to string using toString() String string = sb.toString(); // print string System.out.println('List converted to string: ' + string); } }

Production:

Utilisation de la classe StringBuilder

Le programme ci-dessus montre l'utilisation de l'objet StringBuilder auquel les éléments de la liste sont ajoutés. Ensuite, l'objet est converti en chaîne.

Conversion d'une liste en un tableau

Étant donné une liste d'éléments, vous devez convertir cette liste en un tableau. Pour ce faire, vous pouvez utiliser l'une des méthodes décrites ci-dessous.

# 1) Utilisation de toArray

Le moyen le plus simple de convertir une liste en tableau est d’utiliser la méthode «toArray» de la liste.

Le programme suivant montre cette implémentation de la méthode toArray.

import java.util.*; public class Main { public static void main(String() args) { //create and initialize list List strList = new LinkedList(); strList.add('This'); strList.add('is'); strList.add('Java'); strList.add('Tutorial'); System.out.println('The given list:' + strList); //use toArray method to convert list to array String() strArray = strList.toArray(new String(0)); //print the array System.out.println('The Array from List: '); for (String val : strArray) System.out.print(val + ' '); } }

Production:

Utilisation de toArray

Dans le programme ci-dessus, nous avons converti une liste de chaînes en un tableau de chaînes en utilisant la méthode «toArray».

# 2) Utilisation de Java 8 Stream

où regarder des animes en ligne gratuitement

La méthode suivante pour convertir une liste en tableau consiste à utiliser les API de flux de Java 8. Dans ce cas, la liste est d'abord convertie en flux, puis en utilisant stream (). ToArray, elle est convertie en tableau.

Le programme Java suivant montre cette conversion.

import java.util.*; class Main { public static void main (String()args) { //create and initialize the list List l_list = new LinkedList (); l_list.add ('Software'); l_list.add ('Testing'); l_list.add ('Help'); l_list.add ('Tutorial'); System.out.println('The given list:' + l_list); //Convert list to array using stream and toArray methods String() str_array = l_list.stream ().toArray (String()::new); //print the array System.out.println('The Array converted from list : '); for (String val:str_array) System.out.print (val + ' '); } }

Production:

Utilisation du flux Java 8

Le programme ci-dessus utilise les API de flux de Java 8 et convertit la liste en tableau. Le tableau est ensuite imprimé en utilisant pour chaque boucle.

# 3) Utilisation de la méthode get

Il s'agit d'une autre méthode de conversion de la liste en tableau. En cela, nous utilisons le get () de la liste qui peut être utilisé pour récupérer des éléments individuels de la liste.

Le programme pour convertir la liste en tableau à l'aide de la méthode get () est illustré ci-dessous.

import java.io.*; import java.util.List; import java.util.LinkedList; class Main { public static void main (String() args) { List colors_list = new LinkedList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Yellow'); System.out.println('Given list: ' + colors_list); //define the array String() colors_array = new String(colors_list.size()); // get list elements into the array for (int i =0; i

Production:

Utilisation de la méthode get

Dans le programme ci-dessus, nous avons créé un tableau de la même taille qu'une liste. Ensuite, dans une boucle, les éléments de la liste sont récupérés à l'aide de la méthode get () et affectés au tableau.

Convertir le tableau en liste

Comme vous pouvez convertir une liste en tableau, vous pouvez également convertir un tableau en liste en Java. Vous trouverez ci-dessous quelques-unes des méthodes à l'aide desquelles vous pouvez convertir un tableau en liste.

# 1) Utilisation du code Java brut

Il s'agit de la méthode traditionnelle de conversion d'un tableau en liste. Ici, vous ajoutez chaque élément du tableau à la liste un par un en utilisant une boucle. Pour cette méthode d'ajout de la liste est utilisée.

Le programme suivant implémente la méthode traditionnelle pour convertir un tableau en liste.

import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { // Create and initialize an Array String strArray() = { 'Java', 'Python', 'C++', 'SQL', 'Perl' }; // Print the Array System.out.println('Array: ' + Arrays.toString(strArray)); // Create a List List strlist = new ArrayList(); // Iterate through the array and add each element to the list for (String val : strArray) { strlist.add(val); } // Print the List System.out.println(' List obtained from array: ' + strlist); } }

Production:

Utilisation de code Java brut

# 2) Utilisation de la méthode asList ()

La méthode suivante de conversion d'un tableau en liste consiste à utiliser la méthode asList () de la classe Arrays. Ici, vous pouvez passer Array comme argument à la méthode asList () et il renvoie la liste obtenue.

Le programme suivant le montre.

import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { //create and intialize array Integer() oddArray = { 1,3,5,7,9,11 }; //declare a list and use asList method to assign the array to list List oddList = Arrays.asList(oddArray); // Print the List System.out.println('List from array: ' + oddList); } }

Production:

Utilisation de la méthode asList ()

Dans le programme ci-dessus, nous avons un tableau de nombres impairs. Ensuite, nous créons une liste d'entiers et l'affectons à la sortie de la méthode asList qui est une liste.

# 3) Utilisation de la méthode Collection.addAll ()

Vous pouvez également utiliser la méthode addAll () de la classe Collections car le tableau et la liste font tous deux partie de la structure de collection en Java.

Le programme suivant montre l'utilisation de la méthode Collections.addAll () pour convertir un tableau en liste.

import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { // Create and initialize an Array String strArray() = { 'Java', 'C++', 'C', 'Perl', 'Python' }; // Print the Array System.out.println('Array: ' + Arrays.toString(strArray)); // create a string list List myList = new ArrayList(); // Add array to list using Collections addAll method Collections.addAll(myList, strArray); // Print the List System.out.println('List obtained from array: ' + myList); } }

Production:

Utilisation de la méthode Collection.addAll ()

Ici, nous avons initialisé un tableau. Nous avons créé une liste vide. Ensuite, la méthode Collections.addAll () est utilisée en passant des listes et un tableau comme argument. Une exécution réussie de cette méthode aura une liste remplie avec les éléments du tableau.

# 4) Utilisation des flux Java 8

La prochaine approche pour convertir un tableau en liste consiste à utiliser l'API Java 8 Stream et la classe Collectors. Ici, le tableau est d'abord converti en flux, puis les éléments sont collectés dans une liste à l'aide de stream. Méthode de collecte. La liste est finalement renvoyée.

Le programme suivant montre l'implémentation qui convertit le tableau en liste à l'aide de l'API Stream.

import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { // Create and initialize an Array String colorsArray() = { 'Red', 'Green', 'Blue', 'Yellow', 'Magenta' }; // Print the Array System.out.println('Array: ' + Arrays.toString(colorsArray)); // convert the Array to List using stream () and Collectors class List colorslist = Arrays .stream(colorsArray) .collect(Collectors.toList()); // Print the List System.out.println('List from Array: ' + colorslist); } }

Production:

Utilisation des flux Java 8

Dans le programme ci-dessus, un tableau de couleurs est créé. Une liste vide est créée ensuite, puis la liste obtenue à partir du tableau à l'aide de l'API de flux est affectée à la liste.

Convertir la liste en ensemble

Un ensemble est une collection d'éléments non ordonnés qui n'autorise pas les valeurs en double. Set fait partie du framework Java Collections. Vous pouvez convertir une liste en set et vice-versa si besoin.

Dans cette section, voyons quelques-unes des méthodes utilisées pour convertir une liste en un ensemble.

# 1) Utilisation de la méthode traditionnelle

Vous pouvez convertir la liste à définir en utilisant le code java traditionnel. En cela, vous pouvez créer un HashSet ou un treeSet. Et puis en utilisant la méthode add, ajoutez chaque élément de liste à l'ensemble dans une boucle.

Cette implémentation est illustrée ci-dessous.

import java.util.*; class Main { public static void main(String() args) { // Creating a list of strings List strList = Arrays.asList('Java', 'Perl', 'Python', 'C++', 'C'); //print the list System.out.println('The list : ' + strList); //create a set Set hashSet = new HashSet(); //add list elements to hashset for (String ele : strList) hashSet.add(ele); //print the set System.out.println('HashSet from list:'); for (String val : hashSet) System.out.print(val + ' '); } }

Production:

En utilisant la méthode traditionnelle

Dans le programme ci-dessus, vous pouvez voir que nous avons créé un objet HashSet de type string. Ensuite, à l'aide de la boucle for améliorée, chaque élément de la liste est ajouté à l'ensemble. Enfin, l'ensemble est imprimé.

Lecture recommandée = >> HashSet en Java

# 2) Utilisation de HashSet ou du constructeur d'arbres

La méthode suivante utilise un constructeur d'ensemble. Ici, nous créons un constructeur d'ensemble (treeSet ou HashSet). Une liste est passée à ce constructeur en tant qu'argument. En utilisant cette liste, l'ensemble est construit.

Consultez le programme ci-dessous pour cette implémentation.

import java.util.*; class Main { public static void main(String() args) { // Create a list of strings List strList = Arrays.asList('Red', 'Green', 'Blue', 'Yellow', 'Cyan', 'Magenta'); System.out.println('Original List:' + strList); // Creating a hash set using constructor and pass list to the constructor Set hashSet = new HashSet(strList); System.out.println(' HashSet created from list:'); //print the hashSet for (String val : hashSet) System.out.print(val + ' '); //Create a treeset using constructor and pass list to the constructor Set treeSet = new TreeSet(strList); System.out.println(' TreeSet from list: '); //print the treeset for (String x : treeSet) System.out.print(x + ' '); } }

Production:

Utilisation de HashSet ou du constructeur d

Dans le programme ci-dessus, nous créons à la fois HashSet et treeSet en passant la liste comme argument. Enfin, le contenu de HashSet et de l'ensemble d'arbres est affiché.

# 3) Utilisation de la méthode addAll

C'est la même chose que la méthode addAll des collections que nous avons vue auparavant. Ici, la méthode addAll est utilisée pour copier le contenu de la liste dans l'ensemble.

Le programme suivant montre l'utilisation de la méthode addAll.

import java.util.*; class Main { public static void main(String() args) { // Creating a list of strings List intList = Arrays.asList(1,3,5,7,9,11,13); System.out.println('Original List: ' + intList); //create a hashset Set hashSet = new HashSet(); //add elements of list to hashSet using addAll method hashSet.addAll(intList); System.out.println('HashSet created from list: '); //print the hashSet for (Integer val : hashSet) System.out.print(val + ' '); } }

Production:

Utilisation de la méthode addAll

Ce programme crée un objet HashSet. Ensuite, la méthode addAll est appelée sur l'objet HashSet avec la liste comme paramètre. Cette méthode copie le contenu de la liste dans l'ensemble.

# 4) Utilisation des flux Java 8

Comme déjà vu, vous pouvez également utiliser les flux Java 8 pour convertir la liste en toute autre collection, y compris set. Vous devez utiliser la méthode stream (). Collect pour ce faire.

Le programme suivant montre cette implémentation.

import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create a list of strings List colorsList = Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow'); System.out.println('Original List:' + colorsList); // Convert to set using stream and Collectors class toSet() method Set colorsSet = colorsList.stream().collect(Collectors.toSet()); System.out.println('The set from list:'); //print the set for (String x : colorsSet) System.out.print(x + ' '); }

Production:

Utilisation de Java 8 streams_convert list pour définir

Le programme ci-dessus est similaire à celui montré dans le cas de la conversion de la liste en tableau. Tout d'abord, la liste est convertie en flux, puis la méthode de collecte collecte les éléments de flux et les convertit en ensemble.

Maintenant que nous avons vu diverses méthodes qui effectuent la conversion de la liste à set, voyons les méthodes utilisées pour convertir l'ensemble en liste.

Convertir l'ensemble en liste

Semblable à la façon dont vous convertissez une liste en ensemble, vous pouvez également convertir un ensemble en liste. Vous pouvez utiliser les mêmes méthodes décrites ci-dessus pour cette conversion. La seule différence est que vous changez les emplacements de la liste et les définissez dans le programme.

Vous trouverez ci-dessous des exemples de conversion d'ensemble en liste pour chaque méthode.

# 1) Utilisation de Java brut

importjava.util.*; class Main { public static void main(String() args) { // Create a set(hashset) and initialize it Set hashSet = new HashSet(); hashSet.add('Red'); hashSet.add('Green'); hashSet.add('Blue'); hashSet.add('Cyan'); hashSet.add('Magenta'); hashSet.add('Yellow'); //print the set System.out.println('The set elements:'); for (String x : hashSet) System.out.print(x + ' '); //create a list (ArrayList) List strList = new ArrayList(hashSet.size()); //traverse the set and add its elements to the list for (String x : hashSet) strList.add(x); //print the list System.out.println(' Created ArrayList:' + strList); } }

Production:

Utilisation de Java_convert standard défini sur list

Le programme ci-dessus déclare et initialise un ensemble. Ensuite, il crée une liste et ajoute chaque élément d'ensemble à la liste. Enfin, il imprime la liste.

# 2) Utilisation de constructeurs

import java.util.*; class Main { public static void main(String() args) { // Create a set(hashset) of strings & initialize it Set hashSet = new HashSet(); hashSet.add('Delhi'); hashSet.add('Mumbai'); hashSet.add('Chennai'); hashSet.add('Kolkata'); //print the Set System.out.println('The set :'); for(String str: hashSet) System.out.print(str + ' '); //pass hashset to linkedlist constructor List l_List = new LinkedList(hashSet); //print the linked list System.out.println (' LinkedList from set: ' + l_List); } }

Production:

Utilisation de constructeurs

Ici, vous pouvez utiliser le constructeur de liste avec un objet set comme argument. Cela copie tous les éléments définis dans l'objet de liste.

# 3) Utilisation de la méthode addAll

import java.util.*; class Main { public static void main(String() args) { // Create a set(hashset) of strings & initialize it Set hashSet = new HashSet(); hashSet.add('Red'); hashSet.add('Green'); hashSet.add('Blue'); hashSet.add('Cyan'); hashSet.add('Magenta'); hashSet.add('Yellow'); //print the Set System.out.println('The set: '); for(String x:hashSet) System.out.print(x + ' '); //create a list(ArrayList) List colorList = new ArrayList(); //use addAll method to add elements from set colorList.addAll(hashSet); //print the list System.out.println(' The ArrayList from set: ' + colorList); } }

Production:

Utilisation du paramètre method_convert addAll défini sur list

Dans ce programme, un objet de liste est créé. Ensuite, à l'aide de la méthode Collections.addAll (), les éléments de l'ensemble sont ajoutés à la liste.

# 4) Utilisation de Java 8 Stream

import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create a set(hashset) of strings & initialize the set Set hashSet = new HashSet(); hashSet.add('Yellow'); hashSet.add('Magenta'); hashSet.add('Cyan'); hashSet.add('Red'); hashSet.add('Green'); hashSet.add('Blue'); //print the Set System.out.println('The set:'); for(String str : hashSet) System.out.print(str + ' '); //create a list and assign it elements of set through stream and Collectors class List strList = hashSet.stream().collect(Collectors.toList()); //print the list System.out.println(' List obtained from set: ' + strList); } }

Production:

Utilisation de Java 8 Stream_Convert défini sur list

Vous pouvez également utiliser les flux Java 8 et la méthode de collecte pour convertir l'ensemble dans la liste, comme indiqué dans le programme ci-dessus.

Liste Array Vs

Discutons de certaines des différences entre un tableau et une liste.

Déployer Lister
Le tableau est une structure de données de base en Java.La liste est une interface qui fait partie du framework de collecte en Java à partir duquel de nombreuses classes peuvent être étendues comme LinkedList, ArrayList, etc.
A une taille fixeLa taille de la liste est dynamique.
Les éléments du tableau sont accessibles en utilisant ().Les membres de la liste sont accessibles à l'aide de méthodes.
Le tableau peut avoir des types primitifs ainsi que des objets comme éléments.Les listes ne peuvent contenir que des objets.
Les tableaux peuvent utiliser des opérateurs avec leurs éléments.Les listes ne peuvent pas utiliser d'opérateurs. Au lieu de cela, il répertorie les méthodes d'utilisation.
Les baies ne peuvent pas fonctionner avec des génériques pour garantir la sécurité des types.Les listes peuvent être génériques.

Questions fréquemment posées

Q # 1) Comment convertir une liste en tableau en Java?

Répondre: La méthode de base pour convertir une liste en tableau en Java consiste à utiliser la méthode ‘toArray ()’ de l’interface List.

L'appel simple ci-dessous convertit la liste en tableau.

Object() array = list.toArray();

Il existe également d'autres méthodes décrites ci-dessus pour convertir la liste en tableau.

Q # 2) Un tableau est-il une liste en Java?

Répondre: Non. Un tableau est une structure de base en Java avec une longueur fixe. Il ne s'étend pas à partir de l'interface de liste. La structure qui s'étend de l'interface de liste et similaire à array est ArrayList.

Q # 3) Comment convertir un tableau en liste en Java?

Répondre: L'une des méthodes de base pour convertir un tableau en liste en Java consiste à utiliser la méthode asList () de la classe Arrays.

List aList = Arrays.asList (myarray);

En dehors de cela, il existe d'autres méthodes qui convertissent un tableau en liste, comme indiqué précédemment dans ce didacticiel.

Q # 4) Quel est un ensemble ou une liste plus rapide en Java?

Répondre: Cela dépend des données stockées. Si les données sont uniques, la liste est meilleure et plus rapide. Si vous avez un grand ensemble de données, optez pour des ensembles. La structure d'ensemble nécessite généralement 10 fois plus de mémoire que les listes.

Q # 5) Quelle est la différence entre une ArrayList et un Set?

Répondre: La liste est une collection d'éléments ordonnés tandis que l'ensemble est une collection d'éléments non ordonnés. La liste peut avoir des éléments en double mais l'ensemble ne peut pas avoir d'éléments en double.

Conclusion

Dans ce tutoriel, nous avons vu diverses conversions de liste en tableau, ensemble et vice-versa. Nous avons également vu les principales différences entre un tableau et une liste.

Dans ce prochain tutoriel, nous discuterons en détail des classes de liste telles que ArrayList, LinkedList, etc.

=> Consultez le guide de formation Perfect Java ici.

lecture recommandée

^