Преобразовать набор в список без создания нового списка

Я использую этот код для преобразования Setв List:

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

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

Я хочу избежать создания нового списка в каждой итерации цикла. Это возможно?

Вы можете использовать метод List.addAll () . Он принимает коллекцию в качестве аргумента, а ваш набор является коллекцией.

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

РЕДАКТИРОВАТЬ: как ответить на редактирование вопроса.
Легко видеть, что если вы хотите иметь s Mapсо Listзначениями s, чтобы иметь k разных значений, вам нужно создать k разных списков.
Таким образом: Вы не можете избежать создания этих списков вообще, списки должны быть созданы.

Возможные
обходные пути : Объявите себя Mapкак Map<String,Set>или Map<String,Collection>вместо, и просто вставьте свой набор.

Используйте конструктор, чтобы преобразовать его:

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

Также из библиотеки Guava Collect вы можете использовать newArrayList(Collection):

Lists.newArrayList([your_set])

Это будет очень похоже на предыдущий ответ от amit , за исключением того, что вам не нужно объявлять (или создавать) какой-либо listобъект.

Мы можем использовать следующие один вкладыш в Java 8:

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

Вот один маленький пример:

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());
}

самое простое решение

Я хотел очень быстрый способ преобразовать мой набор в список и вернуть его, поэтому в одной строке я сделал

 return new ArrayList<Long>(mySetVariable);

Вы можете использовать это изменение одной строки: 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()])));
}  

Я бы сделал :

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);
}

Поскольку это не было упомянуто до сих пор, в Java 10 вы можете использовать новый copyOfметод фабрики:

List.copyOf(set);

Из Javadoc :

Возвращает неизменяемый Список, содержащий элементы данной Коллекции, в порядке итерации.

Java 8 предоставляет возможность использования потоков, и вы можете получить список из Set<String> setString:

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

Хотя внутренняя реализация на данный момент обеспечивает экземпляр 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);
    }

но JDK не гарантирует это. Как уже упоминалось здесь :

Нет никаких гарантий относительно типа, изменчивости, сериализуемости или безопасности потока возвращаемого списка; если требуется больший контроль над возвращенным списком, используйте toCollection (Supplier).

Если вы хотите быть уверенным всегда, тогда вы можете запросить экземпляр именно так:

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

Я создаю простой staticметод:

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

... или если вы хотите установить тип списка, вы можете использовать:

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;
}

Недавно я нашел это:

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

Ради полноты ...

Скажите , что вы действительно хотите , чтобы обработать Mapзначения , как Listс, но вы хотите , чтобы избежать копирования Setв Listкаждый момент времени.

Например, может быть, вы вызываете одну библиотечную функцию, которая создает Set, но вы передаете свой Map<String, List<String>>результат библиотечной функции (плохо спроектированной, но не в ваших руках), которая только выполняет Map<String, List<String>>, хотя каким- то образом вы знаете, что она выполняет операции с Lists одинаково применимы к любому Collection(и, следовательно, к любому Set). И по какой-то причине вам нужно избегать накладных расходов на скорость / память при копировании каждого набора в список.

В этом супер нишевом случае, в зависимости от (возможно, непознаваемого) поведения, необходимого библиотечной функции от вашего List, вы можете создать List представление для каждого набора. Обратите внимание, что это по сути небезопасно (поскольку требования библиотечной функции к каждой из них Listмогут предположительно измениться без вашего ведома), поэтому следует предпочесть другое решение. Но вот как ты это сделаешь.

Вы создали бы класс, который реализует Listинтерфейс, принимает Setконструктор и присваивает это значение Set полю, а затем использует его Setдля реализации ListAPI (насколько это возможно и желательно).

Обратите внимание, что какое-то поведение List вы просто не сможете имитировать, не сохраняя элементы как a List, а какое-то поведение вы сможете имитировать лишь частично. Опять же, этот класс не является безопасной заменой Lists в целом. В частности, если вы знаете, что сценарий использования требует операций, связанных с индексом, или MUTATING List, этот подход очень быстро уйдет на юг.

public class ListViewOfSet<U> implements List<U> {
    private final Set<U> wrappedSet;
    public ListViewOfSet(Set<U> setToWrap) { this.wrappedSet = setToWrap; }

    @Override public int size() { return this.wrappedSet.size(); }
    @Override public boolean isEmpty() { return this.wrappedSet.isEmpty(); }
    @Override public boolean contains(Object o) { return this.wrappedSet.contains(o); }
    @Override public java.util.Iterator<U> iterator() { return this.wrappedSet.iterator(); }
    @Override public Object[] toArray() { return this.wrappedSet.toArray(); }
    @Override public <T> T[] toArray(T[] ts) { return this.wrappedSet.toArray(ts); }
    @Override public boolean add(U e) { return this.wrappedSet.add(e); }
    @Override public boolean remove(Object o) { return this.wrappedSet.remove(o); }
    @Override public boolean containsAll(Collection<?> clctn) { return this.wrappedSet.containsAll(clctn); }
    @Override public boolean addAll(Collection<? extends U> clctn) { return this.wrappedSet.addAll(clctn); }
    @Override public boolean addAll(int i, Collection<? extends U> clctn) { throw new UnsupportedOperationException(); }
    @Override public boolean removeAll(Collection<?> clctn) { return this.wrappedSet.removeAll(clctn); }
    @Override public boolean retainAll(Collection<?> clctn) { return this.wrappedSet.retainAll(clctn); }
    @Override public void clear() { this.wrappedSet.clear(); }
    @Override public U get(int i) { throw new UnsupportedOperationException(); }
    @Override public U set(int i, U e) { throw new UnsupportedOperationException(); }
    @Override public void add(int i, U e) { throw new UnsupportedOperationException(); }
    @Override public U remove(int i) { throw new UnsupportedOperationException(); }
    @Override public int indexOf(Object o) { throw new UnsupportedOperationException(); }
    @Override public int lastIndexOf(Object o) { throw new UnsupportedOperationException(); }
    @Override public ListIterator<U> listIterator() { throw new UnsupportedOperationException(); }
    @Override public ListIterator<U> listIterator(int i) { throw new UnsupportedOperationException(); }
    @Override public List<U> subList(int i, int i1) { throw new UnsupportedOperationException(); }
}

...
Set<String> set = getSet(...);
ListViewOfSet<String> listOfNames = new ListViewOfSet<>(set);
...

Я нашел это работает нормально и полезно для создания списка из набора.

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

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));
}