interfaz - java jframe tutorial pdf

Convertir el conjunto a la lista sin crear una nueva lista

Question

Estoy usando este código para convertir un Set en una List :

Map<String, List> mainMap = new HashMap<String, List>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //returns different result each time
  List listOfNames = new ArrayList(set);
  mainMap.put(differentKeyName,listOfNames);
}

Quiero evitar crear una nueva lista en cada iteración del bucle. ¿Es eso posible?

Answer 1

la solución más simple

Quería una forma muy rápida de convertir mi conjunto en Lista y devolverlo, así que en una línea lo hice

 return new ArrayList<Long>(mySetVariable);

Answer 2

Creo un método static simple:

public static <U> List<U> convertSetToList(Set<U> set)
{
    return new ArrayList<U>(set);
}

... o si desea establecer el tipo de Lista puede usar:

public static <U, L extends List<U>> List<U> convertSetToList(Set<U> set, Class<L> clazz) throws InstantiationException, IllegalAccessException
{
    L list = clazz.newInstance();
    list.addAll(set);
    return list;
}

Answer 3

Encontré este trabajo bien y útil para crear una lista de un conjunto.

ArrayList < String > L1 = new ArrayList < String > ();
L1.addAll(ActualMap.keySet());
for (String x: L1) {
    System.out.println(x.toString());
}

Answer 4

Java 8 ofrece la opción de utilizar secuencias y puede obtener una lista de Set<String> setString como:

List<String> stringList = setString.stream().collect(Collectors.toList());

Aunque la implementación interna a partir de ahora proporciona una instancia de ArrayList :

public static <T>
    Collector<T, ?, List<T>> toList() {
        return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
                                   (left, right) -> { left.addAll(right); return left; },
                                   CH_ID);
    }

Pero JDK no lo garantiza. Como se mencionó here :

No hay garantías sobre el tipo, la mutabilidad, la serialización o la seguridad de subprocesos de la Lista devuelta; Si se requiere más control sobre la Lista devuelta, use toCollection (Proveedor).

En caso de que quiera estar siempre seguro, puede solicitar una instancia específicamente como:

List<String> stringArrayList = setString.stream()
                     .collect(Collectors.toCollection(ArrayList::new));

Answer 5

Podemos usar el siguiente liner en Java 8:

List<String> list = set.stream().collect(Collectors.toList());

Aquí hay un pequeño ejemplo:

public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("A");
        set.add("B");
        set.add("C");
        List<String> list = set.stream().collect(Collectors.toList());
}

Answer 6

Podría usar este cambio de una línea: Arrays.asList(set.toArray(new Object[set.size()]))

Map<String, List> mainMap = new HashMap<String, List>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); 
  mainMap.put(differentKeyName, Arrays.asList(set.toArray(new Object[set.size()])));
}  

Answer 7

Puedes usar el método List.addAll() . Acepta una Colección como un argumento, y su conjunto es una Colección.

List<String> mainList = new ArrayList<String>();
mainList.addAll(set);

EDITAR: como responder a la edición de la pregunta.
Es fácil ver que si desea tener un Map con la List s como valores, para tener k valores diferentes, necesita crear k listas diferentes.
Por lo tanto: no puede evitar crear estas listas en absoluto, las listas deberán crearse.

Posible trabajo alrededor de:
Declare su Map como un Map<String,Set> o Map<String,Collection> lugar, y simplemente inserte su conjunto.

Answer 8

Recientemente encontré esto:

ArrayList<T> yourList = Collections.list(Collections.enumeration(yourSet<T>));

Answer 9

También desde la biblioteca Guava Collect, puede usar newArrayList(Collection) :

Lists.newArrayList([your_set])

Esto sería muy similar a la respuesta anterior de amit , excepto que no es necesario declarar (o instanciar) ningún objeto de list .

Answer 10

Usa el constructor para convertirlo:

List<?> list = new ArrayList<?>(set);

Answer 11

Yo lo haría :

Map<String, Collection> mainMap = new HashMap<String, Collection>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //return different result each time
  mainMap.put(differentKeyName,set);
}

Answer 12

Map<String, List> mainMap = new HashMap<String, List>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //return different result each time
  mainMap.put(differentKeyName, new ArrayList(set));
}