Перетворити "Установити в список" без створення нового списку

Я використовую цей код для перетворення 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);

EDIT: як відповідь на редагування питання.
Неважко помітити, що якщо ви хочете мати значення a Mapз Lists як значення, для того щоб мати 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());
}

найпростіше рішення

Я хотів дуже швидким способом перетворити свій набір у List і повернути його, так що в одному рядку я це зробив

 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 (постачальник).

Якщо ви хочете бути впевненими завжди, ви можете подати запит на екземпляр, зокрема:

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для реалізації ListAPI (наскільки це можливо та бажано).

Зауважте, що деяка поведінка списку, яку ви просто не зможете наслідувати, не зберігаючи елементи як а List, а деяку поведінку ви лише частково зможете наслідувати. Знову ж таки, цей клас взагалі не є безпечною заміною для Lists. Зокрема, якщо ви знаєте, що для використання випадку потрібні операції, пов’язані з індексом, або ВИМКНЕННЯ 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));
}