Comment convertir un ensemble en liste en Java
L'interface java.util.Collection est étendue par Java Set, qui fait partie du package java.util. Il n'autorise pas les éléments en double et ne peut contenir qu'un composant nul à la fois.
La liste est l'interface enfant d'une collection. C'est une collection triée d'objets qui peuvent stocker des valeurs en double. De plus, la liste prend en charge l'accès positionnel et l'insertion de membres car l'ordre d'insertion est préservé. Les classes ArrayList, LinkedList, Vector et Stack implémentent également l'interface List.
En Java, une liste est une collection ordonnée de données, alors qu'un ensemble est une collection non ordonnée. Un ensemble ne peut pas avoir d'entrées en double, contrairement à une liste. Les deux structures de données sont utiles dans diverses situations. Il est utile de savoir comment transformer un ensemble en liste. Par exemple, il peut convertir des données qui ne sont pas dans un ordre particulier en données qui le sont.
Créer un nouvel ensemble
Commençons par créer un ensemble, puis en y ajoutant quelques éléments.
import java.util.*;
public class Main {
public static void main(String[] args)
{
Set<Integer> intList = new HashSet<>();
intList.add(1);
intList.add(2);
intList.add(3);
intList.add(1);
System.out.println(intList);
}
} La méthode add() de HashSet ajoute les composants à l'ensemble. Il est important de noter que les éléments sont distincts. Étant donné que les ensembles ne sont pas ordonnés, il n'y a aucun moyen d'acquérir les composants dans l'ordre dans lequel ils ont été insérés.
Conversion Java d'un ensemble en liste
Faisons une liste de l'ensemble. Il existe plusieurs options pour le faire. En fait, chaque méthode est distincte des autres. Cependant, les distinctions sont mineures.
Constructeur d'une List avec un argument Set
La façon la plus simple de convertir un ensemble en liste est d'utiliser l'ensemble comme argument lors de la construction de la liste. Le constructeur est invoqué à cause de cela, et le constructeur s'occupe du reste. En Java, les collections comportent un constructeur où l'ensemble direct est fourni pour produire une liste.
Algorithme :
- Obtenez l'ensemble que vous avez l'intention de transformer.
- En fournissant l'ensemble comme argument au constructeur, vous pouvez créer une liste.
- Renvoyer la liste créée.
import java.util.*;
public class Main {
public static void main(String[] args)
{
Set<Integer> intList = new HashSet<>();
intList.add(1);
intList.add(2);
intList.add(3);
intList.add(1);
List<Integer> arr = new ArrayList<>(intList);
System.out.println(arr);
System.out.println(arr.get(1));
}
} Les éléments sont maintenant organisés car l'ensemble a été remplacé par une liste. Cela signifie que nous pouvons récupérer les détails par index en utilisant la méthode get().
Exemple :programme de conversion d'un ensemble en liste en Java
import java.util.*;
import java.util.stream.*;
class Codeunderscored {
// Generic function to convert set to list
public static <T> List<T> convertSetToList(Set<T> set)
{
// create a list from Set
List<T> list = new ArrayList<>(set);
// return the list
return list;
}
public static void main(String args[])
{
// Create a Set using HashSet
Set<String> laptopHashSet = new HashSet<String>();
// Add elements to set
laptopHashSet.add("Geeks");
laptopHashSet.add("For");
laptopHashSet.add("Geeks");
laptopHashSet.add("Example");
laptopHashSet.add("Set");
// Print the Set
System.out.println("Set: " + laptopHashSet);
// construct a new List from Set
List<String> list = convertSetToList(laptopHashSet);
// Print the List
System.out.println("List: " + list);
}
} Exemple :Utilisation d'un constructeur
import java.util.*;
import java.util.stream.*;
class example {
// Generic function to convert set to list
public static <T> List<T> convertSetToList(Set<T> set)
{
// create a list from Set
List<T> list = new ArrayList<>(set);
// return the list
return list;
}
public static void main(String args[])
{
// Create a Set using HashSet
Set<String> codeSet = new HashSet<String>();
// Add elements to set
codeSet.add("Code");
codeSet.add("Underscored");
codeSet.add("Set");
codeSet.add("to");
codeSet.add("list");
codeSet.add("example");
// Print the Set
System.out.println("Set: " + codeSet);
// construct a new List from Set
List<String> list = convertSetToList(hash_Set);
// Print the List
System.out.println("List: " + list);
}
} Utiliser une boucle traditionnelle
Pour copier explicitement les éléments de l'ensemble vers la liste, nous pouvons utiliser le bon vieux for a loop. La force brute ou la méthode naïve consiste à créer une liste vide, puis à y ajouter chaque élément de l'ensemble.
Algorithme :
- Obtenez l'ensemble qui sera transformé.
- Faire une liste vide.
- Remplissez la liste avec chaque élément de l'ensemble.
- Renvoyer la liste résultante créée.
import java.util.*;
public class Main {
public static void main(String[] args)
{
Set<Integer> intList = new HashSet<>();
intList.add(1);
intList.add(2);
intList.add(3);
intList.add(1);
List<Integer> arr = new ArrayList<>(intList);
for (int i : a)
arr.add(i);
System.out.println(arr);
System.out.println(arr.get(1));
}
} La boucle for parcourt l'ensemble, ajoutant chaque élément à la liste.
Exemple :programme de conversion d'un ensemble en liste en Java 8
import java.util.*;
import java.util.stream.*;
class Codeunderscored {
// Generic function to convert set to list
public static <T> List<T> convertSetToList(Set<T> set)
{
// create an empty list
List<T> list = new ArrayList<>();
// push each element in the set into the list
for (T t : set)
list.add(t);
// return the list
return list;
}
public static void main(String args[])
{
// Create a Set using HashSet
Set<String> hash_Set = new HashSet<String>();
// Add elements to set
hash_Set.add("Code");
hash_Set.add("For");
hash_Set.add("Underscored");
hash_Set.add("Python");
hash_Set.add("Set");
// Print the Set
System.out.println("Set: " + hash_Set);
// construct a new List from Set
List<String> list = convertSetToList(hash_Set);
// Print the List
System.out.println("List: " + list);
}
} Exemple 3 :Utilisation d'une boucle traditionnelle
import java.util.*;
import java.util.stream.*;
class example {
// Generic function to convert set to list
public static <T> List<T> convertSetToList(Set<T> set)
{
// create an empty list
List<T> list = new ArrayList<>();
// push each element in the set into the list
for (T t : set)
list.add(t);
// return the list
return list;
}
public static void main(String args[])
{
// Create a Set using HashSet
Set<String> codeSet = new HashSet<String>();
// Add elements to set
codeSet.add("Code");
codeSet.add("Underscored");
codeSet.add("Set");
codeSet.add("to");
codeSet.add("list");
codeSet.add("example");
// Print the Set
System.out.println("Set: " + codeSet);
// construct a new List from Set
List<String> list = convertSetToList(codeSet);
// Print the List
System.out.println("List: " + list);
}
} Utilisez la fonction addAll() pour ajouter tous les éléments à une liste.
AddAll() est une méthode de liste qui ajoute plusieurs valeurs à la liste à la fois. Cette opération peut vous être familière de par son utilisation dans la fusion de deux listes. addAll() peut également ajouter les éléments d'un ensemble à une liste.
import java.util.*;
public class Main {
public static void main(String[] args)
{
Set<Integer> intList = new HashSet<>();
intList.add(1);
intList.add(2);
intList.add(3);
intList.add(1);
List<Integer> arr = new ArrayList<>();
arr.addAll(intList);
System.out.println(arr);
System.out.println(arr.get(1));
}
} }
La méthode collect() de l'API Stream
À partir de Java 8, Stream.collect() est pris en charge. Tous les éléments Stream sont collectés dans un objet List via le collecteur ToList. Dans Java 8, vous pouvez convertir un ensemble en liste en utilisant Set.stream() pour convertir l'ensemble en flux séquentiel, puis en utilisant un collecteur pour rassembler les éléments d'entrée dans une nouvelle liste.
// This is Generic method to convert a set to a list
public static <T> List<T> convertToList(Set<T> set) {
return set.stream().collect(Collectors.toList());
} Nous pouvons utiliser Collectors.toCollection() pour spécifier la Collection souhaitée car Collectors.toList() ne garantit pas le type de List renvoyé :
// This a Generic method to convert a set to `ArrayList`
public static <T> List<T> convertToList(T[] arr) {
return set.stream().collect(Collectors.toCollection(ArrayList::new));
} Algorithme :
- Obtenez le HashMap qui sera transformé.
- Créer un flux à partir de l'ensemble
- Convertir l'ensemble en liste et l'ajouter à votre collection.
- Renvoyer la liste qui a été collectée.
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args)
{
Set<Integer> intList = new HashSet<>();
intList.add(1);
intList.add(2);
intList.add(3);
intList.add(1);
List<Integer> arr;
arr = intList.stream().collect(Collectors.toList());
System.out.println(arr);
System.out.println(arr.get(1));
}
} Le type, la mutabilité, la sérialisabilité et la sécurité des threads de la liste retournée ne sont pas garantis. C'est selon la documentation de stream.collect(). Utilisez toCollection(Supplier) si vous avez besoin d'un meilleur contrôle sur la liste renvoyée.
Utilisez toCollection(ArrayList::new) pour spécifier le type de liste
pubimport java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args)
{
Set<Integer> intList = new HashSet<>();
intList.add(1);
intList.add(2);
intList.add(3);
intList.add(1);
List<Integer> arr;
arr = intList.stream().collect(Collectors.toCollection(ArrayList::new));
System.out.println(arr);
System.out.println(arr.get(1));
}
}
Exemple :Programme de conversion d'un HashMap en TreeMap en Java
import java.util.*;
import java.util.stream.*;
class Codeunderscored {
// Generic function to convert set to list
public static <T> List<T> convertSetToList(Set<T> set)
{
// create a list from Set
return set
// Create stream from the Set
.stream()
// Convert the set to list and collect it
.collect(Collectors.toList());
}
public static void main(String args[])
{
// Create a Set using HashSet
Set<String> languageSet = new HashSet<String>();
// Add elements to set
languageSet.add("Java");
languageSet.add("Python");
languageSet.add("HTML");
languageSet.add("JavaScript");
languageSet.add("Kotlin");
// Print the Set
System.out.println("Set: " + languageSet);
// construct a new List from Set
List<String> list = convertSetToList(languageSet);
// Print the List
System.out.println("List: " + list);
}
} Utiliser la fonction List.copyOf()
La méthode copyOf() est disponible dans Java 10 et versions ultérieures. La méthode renvoie une List immuable contenant les éléments de la Collection fournie dans l'ordre dans lequel ils ont été itérés. Il ne peut pas y avoir d'éléments nuls dans la liste. Si l'ensemble inclut ' null, ' la méthode lève une exception de pointeur null.
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args)
{
Set<Integer> intList = new HashSet<>();
intList.add(1);
intList.add(2);
intList.add(3);
intList.add(1);
List<Integer> arr;
arr = List.copyOf(intList);
System.out.println(arr);
System.out.println(arr.get(1));
}
} Tentative de conversion d'un ensemble en liste après avoir ajouté un null :
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args)
{
Set<Integer> intList = new HashSet<>();
intList.add(1);
intList.add(2);
intList.add(3);
intList.add(1);
intList.add(null);
List<Integer> arr;
arr = List.copyOf(intList);
System.out.println(arr);
System.out.println(arr.get(1));
}
} Si vous essayez d'ajouter un nouvel élément à une liste immuable, vous obtiendrez une erreur similaire à celle-ci. Pour convertir un ensemble avec un élément nul en liste, utilisez la méthode addAll() :
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args)
{
Set<Integer> intList = new HashSet<>();
intList.add(1);
intList.add(2);
intList.add(3);
intList.add(1);
intList.add(null);
List<Integer> arr = new ArrayList<>();
arr.addAll(intList);
// arr = List.copyOf(intList);
System.out.println(intList);
System.out.println(arr.get(1));
}
} Il convient de noter que le null est en haut de la liste.
Exemple :Utilisation de la fonction List.copyOf()
public void usingJava10ToConvertSetToList() {
Set<Integer> positionSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
List<Integer> targetList = List.copyOf(positionSet);
} Utilisation de Guava Library List.newArrayList(set)
Lists.newArrayList(set) génère une instance ArrayList mutable à l'aide des éléments de l'ensemble fourni. Si nous devons ajouter ou supprimer des éléments ultérieurement, ou si certains des composants sont nuls, c'est mieux.
// This is a Generic method to convert a set to a list
public static <T> List<T> convertToList(Set<T> set) {
return Lists.newArrayList(set);
} ImmutableList.copyOf est une autre option qui renvoie une liste immuable contenant l'ensemble des éléments fournis. Lorsque la mutabilité n'est pas requise, vous devez l'utiliser.
// This is a Generic method to convert a set to a list
public static <T> List<T> convertToList(Set<T> set) {
return ImmutableList.copyOf(set);
} Algorithme :
- Obtenez l'ensemble qui sera transformé.
- À l'aide des listes, créez une nouvelle liste.
- Vous pouvez créer une liste de tableaux en fournissant l'ensemble comme argument à la fonction newArrayList() de la bibliothèque Guava.
- Renvoyer la liste qui a été créée.
Exemple :Programme de conversion de HashMap en TreeMap en Java
import java.util.*;
import java.util.stream.*;
class Codeunderscored {
// Generic function to convert set to list
public static <T> List<T> convertSetToList(Set<T> set)
{
// create a list from Set
return Lists.newArrayList(set);
}
public static void main(String args[])
{
// Create a Set using HashSet
Set<String> languageSet = new HashSet<String>();
// Add elements to set
languageSet.add("Java");
languageSet.add("Python");
languageSet.add("HTML");
languageSet.add("JavaScript");
languageSet.add("Kotlin");
// Print the Set
System.out.println("Set: " + languageSet);
// construct a new List from Set
List<String> list = convertSetToList(languageSet);
// Print the List
System.out.println("List: " + list);
}
} Exemple :Conversion à l'aide de Guava
public void usingGuavaToConvertSetToList() {
Set<Integer> positionList = Sets.newHashSet(0, 1, 2, 3, 4, 5);
List<Integer> targetList = Lists.newArrayList(positionList);
} C'est assez similaire à la technique Java mais avec moins de duplication de code.
Utilisation des collections Apache Commons
Ensuite, pour convertir entre une liste et un ensemble, nous utiliserons l'API Commons Collections :
public void usingCommonsCollectionsToConvertSetToList() {
Set<Integer> positionSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
List<Integer> targetList = new ArrayList<>(6);
CollectionUtils.addAll(targetList, positionSet);
} Conclusion
L'interface java.util.Collection est étendue par un ensemble Java, qui fait partie du package java.util. Il ne peut y avoir aucun élément en double dans un ensemble Java et un seul élément nul est autorisé. De plus, une liste Java est une collection de choses disposées dans un ordre spécifique. En fait, une liste Java, contrairement à un Java Set, peut avoir des valeurs en double.
Nous avons vu des approches très créatives pour convertir un ensemble en liste. Il est crucial de faire attention au type de liste de chaque technique. La méthode copyOf(), par exemple, crée une liste immuable qui ne peut pas inclure d'éléments nuls. Stream.collect(), en revanche, ne donne aucune garantie. Néanmoins, les fonctions constructeur et addAll() sont les plus fiables du batch.
