Ініціалізація ArrayList в одному рядку


2755

Я хотів створити список варіантів для тестування. Спочатку я зробив це:

ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");

Потім я відновив код наступним чином:

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Чи є кращий спосіб зробити це?


34
Якщо це призначено для тестування одиниць, спробуйте підтягнути гойдалку. Ви можете написати свій тестовий код у ньому під час тестування Java-коду, а використовуватиArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"]
ripper234

3
У Java SE 7 можна замінити параметризований тип конструктора порожнім набором параметрів типу (<>): Map <String, List <String>> myMap = new HashMap <> ();
Роза


2
використовуйте ініціалізацію подвійної дуги :)
Mohammadreza Khatami

8
Stream.of ("val1", "val2"). Збирати (Collectors.toList ()); // створює рішення ArrayList, Java8.
torina

Відповіді:


2024

Насправді, мабуть, "найкращим" способом ініціалізації ArrayListє метод, який ви написали, оскільки для цього не потрібно створювати новий List:

ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

Проблема полягає в тому, що для посилання на цей listекземпляр потрібне досить багато тексту .

Існують альтернативи, такі як створення анонімного внутрішнього класу з ініціалізатором екземпляра (також відомим як "ініціалізація подвійної дужки"):

ArrayList<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};

Однак мені не надто подобається цей метод, оскільки те, що ви закінчуєте, - це підклас, ArrayListякий має ініціалізатор екземплярів, і цей клас створений просто для створення одного об’єкта - це просто здається мені трохи зайвим.

Що було б добре, якби було прийнято пропозицію збірника літератури для проектної монети (її планується впровадити в Java 7, але ймовірно, що вона не буде частиною Java 8):

List<String> list = ["A", "B", "C"];

На жаль, це вам тут не допоможе, оскільки буде ініціалізувати незмінне, Listа не ArrayList, і, крім того, воно ще недоступне, якщо воно колись буде.


172
Дивіться stackoverflow.com/questions/924285 для отримання додаткової інформації про подвійну дужку ініціалізації, плюси та мінуси.
Едді

6
@ Eddie: Хороший дзвінок для посилання - одного речення щодо ініціалізації подвійної дужки недостатньо, щоб описати його повністю.
coobird

2
Працює лише в тому випадку, якщо ви не покладаєтесь на список автоматичного боксу <Double> list = [1.0, 2.0, 3.0]; не вдається.
Річард Б

1
Вам не вистачає крапки з комою в ініціалізації подвійного списку
Дон Ларінкс

6
Оскільки ця відповідь є найбільш популярною та згаданою проектною монетою, я думаю, вам слід зауважити, що java 9 поставляється із синтаксисом List.of (...): docs.oracle.com/javase/9/docs/api/java/util/ List.html # of-E ...-
Асаф

2155

Було б простіше, якби ви просто оголосили це як List- чи повинен це бути ArrayList?

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Або якщо у вас є лише один елемент:

List<String> places = Collections.singletonList("Buenos Aires");

Це означатиме, що placesце незмінне (спроба змінити його спричинить викид UnsupportedOperationExceptionвиключення).

Щоб скласти змінений список, який є конкретним, ArrayListви можете створити ArrayListз незмінного списку:

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

18
@Marcase: Ви не можете змінити свій клас, щоб використовувати Список замість ArrayList?
Лоуренс Дол,

74
Згідно з моєю відповіддю, якщо ви не використовуєте конкретні методи ArrayList, краще було б змінити декларацію на List. Вкажіть інтерфейси, а не реалізації.
Крістоффер Хаммарстрем

9
@Christoffer Hammarström: якщо він змінить декларацію на List і використовує Список <String> місця = Arrays.asList (...); він не зможе користуватися place.add ("blabla")
макс

57
Щоб було зрозуміло, asList(...)повертає фіксований розмір, Listякий підіймається на мутуючих операціях, таких як, removeі clearте, що Listконтракт вимагає підтримувати. Навіть якщо ви залишили декларацію як List, вам потрібно використовувати List l = new ArrayList(asList(...)), щоб отримати об’єкт, який не кидає винятки OperationNotSupported. Ліськов Заміна Принцип кому?
Сплеск

5
@Splash: removeі clearнеобов'язкові операції в List, так asList(...)само, відповідно до договору. Ніде ОП не каже, що йому потрібно додавати більше елементів пізніше, приклад є лише тим, Listщо потрібно ініціалізувати трьома елементами.
Крістофер Хаммарстрем

871

Проста відповідь

У Java 9 або новіших версіях після List.of()додано:

List<String> strings = List.of("foo", "bar", "baz");

З Java 10 або пізнішої версії це можна скоротити за допомогою varключового слова.

var strings = List.of("foo", "bar", "baz");

Це дасть вам непорушну силу List , тому її неможливо змінити.
Що саме ви хочете в більшості випадків, коли ви нарощуєте це.


Java 8 або новіші версії:

List<String> strings = Arrays.asList("foo", "bar", "baz");

Це дасть вам Listпідтримку масиву, тому він не може змінити довжину.
Але ти можеш зателефонувати List.set, тож він все ще змінюється .


Можна стати Arrays.asListще коротшим за допомогою статичного імпорту:

List<String> strings = asList("foo", "bar", "baz");

Статичний імпорт:

import static java.util.Arrays.asList;  

Що будь-який сучасний IDE запропонує і автоматично зробить для вас.
Наприклад, в IntelliJ IDEA ви натискаєте Alt+Enterта вибираєте Static import method....


Однак я не рекомендую скорочувати List.ofметод of, оскільки це стає заплутаним.
List.ofвже досить короткий і добре читає.


Використання Streams

Чому це повинно бути List?
З Java 8 або новішої версії ви можете використовувати Streamгнучкіший:

Stream<String> strings = Stream.of("foo", "bar", "baz");

Ви можете об'єднати Streams:

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

Або ви можете перейти від точки Streamдо List:

import static java.util.stream.Collectors.toList;

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

Але бажано просто скористатись, Streamне збираючи її до а List.


Якщо ви дійсно потребуєтеjava.util.ArrayList

(Ви, мабуть, не знаєте .)
Щоб цитувати JEP 269 (акцент мій):

Існує невеликий набір випадків використання для ініціалізації змінного екземпляра колекції з попередньо визначеним набором значень. Зазвичай бажано, щоб ці заздалегідь задані значення були у незмінній колекції, а потім ініціалізувати колекцію змінних через конструктор копій.


Якщо ви хочете одночасно популяризувати ArrayList та додати до нього згодом (чому?), Використовуйте

ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");

або на Java 8 чи новіших версіях:

ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");

або використовуючи Stream:

import static java.util.stream.Collectors.toCollection;

ArrayList<String> strings = Stream.of("foo", "bar")
                             .collect(toCollection(ArrayList::new));
strings.add("baz");

Але знову ж таки, краще просто скористатися Streamбезпосередньо, а не збирати його на a List.


Програма на інтерфейси, а не на реалізацію

Ви сказали, що ви оголосили список ArrayListу своєму коді, але це слід робити лише у тому випадку, якщо ви використовуєте когось із членів, ArrayListяких немає List.

Що ви, швидше за все, не робите.

Як правило , ви повинні просто оголосити змінні найбільш загальний інтерфейс , який ви збираєтеся використовувати (наприклад Iterable, Collectionчи List) і форматувати їх з виконанням конкретної (наприклад ArrayList, LinkedListчи Arrays.asList()).

Інакше ви обмежуєте свій код саме певним типом, і це буде важче змінити, коли ви хочете.

Наприклад, якщо ви переходите ArrayListдо void method(...):

// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) { 
    for (String s : strings) { ... } 
}

// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
    if (!strings.isEmpty()) { strings.stream()... }
}

// List if you also need .get(index):
void method(List<String> strings) {
    strings.get(...)
}

// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
    ??? // You don't want to limit yourself to just ArrayList
}

Іншим прикладом завжди буде оголошення змінної "a", InputStreamхоча це звичайно a FileInputStreamабо a BufferedInputStream, тому що одного разу незабаром ви або хтось інший захочете використовувати якийсь інший тип InputStream.


3
@jollyroger: Arrays.asListстатичний метод. Дивіться docs.oracle.com/javase/1.5.0/docs/guide/language/…
Christoffer Hammarström

2
@ ChristofferHammarström У цьому випадку мій розум-початківець говорить мені, що статичний імпорт має велику схожість із глобальними змінними та небезпеками, які стосуються такого використання. Чи правильне це припущення і чи це також причина подібної відповіді вище, щоб отримати більше голосів?
jollyroger

2
Відповідь вище, я думаю, про яку ви говорили, була зроблена за рік до цього. І ні, проблема з глобальними змінними полягає в тому, що вони змінюються. Вони не мають нічого спільного зі статичним імпортом.
Крістофер Хаммарстрем

2
Якщо ви не хочете статичного імпорту, ви також можете визначити повний шлях до статичного методу asList, так: Список <String> рядків = java.util.Arrays.asList ("", "");
Geert Weening

2
Або ви можете використовувати import java.util.Arrays; та Arrays.asList ("", ""); Вам не доведеться використовувати статичний імпорт. Вам не доведеться використовувати повний шлях. Статичні методи не стосуються імпорту. Вони просто дратуються, якщо ви використовуєте екземпляр, щоб знайти їх.
candied_orange

111

Якщо вам потрібен простий список розміром 1:

List<String> strings = new ArrayList<String>(Collections.singletonList("A"));

Якщо вам потрібен список з декількох об'єктів:

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");

57

З Guava ви можете написати:

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

У Гуаві також є інші корисні статичні конструктори. Про них ви можете прочитати тут .


1
Я впевнений, що ви можете це зробити з java.util.Arraysтакими, як,List<String> names = Arrays.asList("Beckah", "Sam", "Michael");
Бекка,

2
@beckah метод Arrays.asLists створює об'єкт типу List, тоді як питання про створення ArrayList
Paweł Adamski


34

Літерали колекції не перетворили його на Java 8, але можна використовувати API Stream для ініціалізації списку в одному досить довгому рядку:

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

Якщо вам необхідно переконатися , що ваш Listє ArrayList:

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));

34

З і вище, як запропоновано в JEP 269: Фабричні методи колекцій зручності , це можна досягти, використовуючи літеральні збірники, що тепер -

List<String> list = List.of("A", "B", "C");

Set<String> set = Set.of("A", "B", "C");

Аналогічний підхід застосовуватиметься Mapтакож і до -

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

що схоже на пропозицію колекції Literals, як заявив @coobird. Далі уточнено також у JEP -


Альтернативи

Зміни мови були розглянуті кілька разів та відхилені:

Пропозиція монети проекту, 29 березня 2009 року

Пропозиція монети проекту, 30 березня 2009 року

Дискусія JEP 186 про лямбда-дев, січень-березень 2014 року

Мовні пропозиції були відкладені на відміну від пропозиції, що базується на бібліотеці, як узагальнено в цьому повідомленні.

Пов’язано: Який сенс перевантажених заводських методів зручності для колекцій на Java 9


31
import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");

4
Я не хочу додавати нову залежність просто для цього.
Макарс

6
Це те саме Collections.unmodifiableList(Arrays.asList("Buenos Aires", "Córdoba", "La Plata")), що стає unmodifiableList(asList("Buenos Aires", "Córdoba", "La Plata"))зі статичним імпортом. Колекції Google для цього вам не потрібні.
Крістофер Хаммарстрем

9
Ні, це не те саме. Оскільки ImmutableList документує свою незмінність у результаті результату, коли незмінюваний список маскує його як звичайний список.
Девід П'єр

2
Замість незмінного, колекції google також пропонують список змінних масивів: List <String> = Lists.newArrayList ("Буенос-Айрес", "Кордова", "Ла-Плата");
Л. Голландія

3
Ви збираєтеся передати це ImmutableListіншим методам, які застосовують List, і ви все одно втратили цю документацію.
Крістофер Хаммарстрьом

23

Ви можете створити заводський метод:

public static ArrayList<String> createArrayList(String ... elements) {
  ArrayList<String> list = new ArrayList<String>();
  for (String element : elements) {
    list.add(element);
  }
  return list;
}

....

ArrayList<String> places = createArrayList(
  "São Paulo", "Rio de Janeiro", "Brasília");

Але це не набагато краще, ніж ваш перший рефакторинг.

Для більшої гнучкості він може бути загальним:

public static <T> ArrayList<T> createArrayList(T ... elements) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : elements) {
    list.add(element);
  }
  return list;
}

1
Погляньте на початковий пост, він вимагає ініціалізації масиву в одному рядку , а не 7 додаткових рядків.
L. Holanda

7
@LeoHolanda: Створювати заводські методи для кожної дрібниці - це занадто багато, я згоден. Але залежно від ситуації та кількості разів, коли цей метод буде використаний, це може мати сенс створити його. Створення додаткових шарів абстракції має на меті усунути складність, створивши більш значущі методи, що фіксують наміри дизайнера.
Йордао

16

У Java 9 ми можемо легко ініціалізувати ArrayListодин рядок:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

або

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Цей новий підхід Java 9 має багато переваг перед попередніми:

  1. Ефективність простору
  2. Незмінюваність
  3. Нитка безпечна

Докладнішу інформацію див. У цій публікації -> Яка різниця між List.of та Arrays.asList?


8

Про найбільш компактний спосіб це зробити:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);

8

Просто використовуйте наведений нижче код наступним чином.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};

2
@bsd Ви можете використовувати цей метод для оголошення списку перед введенням будь-якого методу. Тож, визначаючи змінні класу, вміст можна додавати до списку, не вимагаючи методу для цього.
melwil

2
слід уникати подвійної дужки ініціалізації, наскільки це можливо. дивіться: stackoverflow.com/a/924326/760393
Рауль

8

За допомогою Eclipse Collection ви можете написати наступне:

List<String> list = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");

Ви також можете бути більш конкретними щодо типів та того, чи є вони змінними чи незмінними.

MutableList<String> mList = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableList<String> iList = Lists.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Ви також можете зробити те ж саме з наборами та сумками:

Set<String> set = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableSet<String> mSet = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet<String> iSet = Sets.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Bag<String> bag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableBag<String> mBag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableBag<String> iBag = Bags.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Примітка. Я є членом колекції Eclipse.


7

Ось ще один спосіб:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());

7

(Має бути коментар, але занадто довгий, тому нова відповідь). Як вже згадували інші, Arrays.asListметод має фіксований розмір, але це не єдина проблема з ним. Він також не справляється зі спадщиною дуже добре. Наприклад, припустимо, у вас є наступне:

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

Вищезазначене призводить до помилки компілятора, оскільки List<B> (що повертається Arrays.asList) не є підкласом List<A>, навіть якщо ви можете додати до List<A>об'єкта об'єкти типу B. Щоб обійти це, вам потрібно зробити щось на кшталт:

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

Це, мабуть, найкращий спосіб зробити це, особливо. якщо вам потрібен необмежений список або вам потрібно використовувати спадщину.


6

Ви можете використовувати наведені нижче твердження:

Фрагмент коду:

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);

Ви можете вкласти перший вираз, щоб мати компактне рішення:letters = Arrays.asList(new String[]{"A", "B", "C"});
Павло Рєпін,

5

Як сказав Том :

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Але оскільки ви скаржилися на те, що хочете ArrayList, ви повинні спочатку знати, що ArrayList - це підклас Список, і ви можете просто додати цей рядок:

ArrayList<String> myPlaces = new ArrayList(places);

Хоча, це може змусити вас поскаржитися на "виконання".

У цьому випадку для мене це не має сенсу, чому, оскільки ваш список визначений заздалегідь, він не визначався як масив (оскільки розмір відомий під час ініціалізації). І якщо це варіант для вас:

String[] places = {"Buenos Aires", "Córdoba", "La Plata"};

Якщо вас не хвилюють незначні відмінності в продуктивності, ви також можете скопіювати масив у ArrayList дуже просто:

ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));

Гаразд, але в майбутньому вам потрібно трохи більше, ніж просто назва місця, вам також потрібен код країни. Якщо припустити, що це все-таки заздалегідь визначений список, який ніколи не змінюватиметься під час виконання, тоді він підходить використовувати enumнабір, який вимагатиме повторної компіляції, якщо список потрібно буде змінити в майбутньому.

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

стане:

enum Places {
    BUENOS_AIRES("Buenos Aires",123),
    CORDOBA("Córdoba",456),
    LA_PLATA("La Plata",789);

    String name;
    int code;
    Places(String name, int code) {
      this.name=name;
      this.code=code;
    }
}

У Enum's є статичний valuesметод, який повертає масив, що містить усі значення enum у порядку, де вони оголошені, наприклад:

for (Places p:Places.values()) {
    System.out.printf("The place %s has code %d%n",
                  p.name, p.code);
}

У цьому випадку я думаю, вам не знадобиться ваш ArrayList.

PS Randyaa продемонстрував ще один приємний спосіб, використовуючи метод статичної утиліти Collections.addAll .


5

У Java 9 є такий спосіб створення непорушного списку:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

який легко адаптується для створення змінного списку, якщо потрібно:

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Подібні методи доступні для Setта Map.


1
Добре, що ви чітко сказали "незмінний список", а потім показали ще один приклад змінного списку, оскільки це дає зрозуміти, який слід використовувати, коли.
cherit


4

Так, за допомогою масивів ви можете ініціалізувати список масивів в одному рядку,

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");



2

У Java не можна робити

ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Як було зазначено, вам потрібно буде зробити ініціалізацію подвійної дужки:

List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};

Але це може змусити вас додавати примітку @SuppressWarnings("serial")або генерувати послідовний UUID, який дратує. Крім того, більшість форматів коду розгорнуть це в декілька операторів / рядків.

Можна також зробити

List<String> places = Arrays.asList(new String[] {"x", "y" });

але тоді ви, можливо, захочете зробити це @SuppressWarnings("unchecked").

Крім того, на думку javadoc, ви повинні зробити це:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Але я не в змозі змусити його компілювати з JDK 1.6.


5
Неправильно! Ви можете зробити перший рядок, і це правильна відповідь btw
богемський

1
Collections.singletonList(messageBody)

Якщо вам знадобиться список одного елемента !

Колекції - з пакету java.util .


1

Найкращий спосіб зробити це:

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

Просто створіть функцію, яка може мати скільки завгодно елементів, і зателефонуйте їй, щоб додати їх в один рядок.


1
Якщо ви зіткнетеся з усіма проблемами, ви можете зробити це шаблоновим методом замість того, щоб використовувати звичайний Object.
Роберт

1

Ось код від AbacusUtil

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

Декларація: я розробник AbacusUtil.


0

Для мене Arrays.asList () - найкращий і зручний. Мені завжди подобається ініціалізувати саме так. Якщо ви новачок в Java Collections, то я хотів би, щоб ви посилалися на ініціалізацію ArrayList


Чому Arrays.asList () краще, ніж створювати новий ArrayList в одному рядку з add()методами?
ІгорГанапольський

0

Чому б не зробити просту функцію утиліти, яка це робить?

static <A> ArrayList<A> ll(A... a) {
  ArrayList l = new ArrayList(a.length);
  for (A x : a) l.add(x);
  return l;
}

" ll" означає "буквальний список".

ArrayList<String> places = ll("Buenos Aires", "Córdoba", "La Plata");

0

що цікаво, жоден вкладиш з іншим перевантаженим Stream::collect методом не вказаний

ArrayList<String> places = Stream.of( "Buenos Aires", "Córdoba", "La Plata" ).collect( ArrayList::new, ArrayList::add, ArrayList::addAll );

-1

Насправді це можливо зробити в один рядок:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})

3
Чи можу я запитати, що це додає до питання? Ця відповідь вже кілька разів висвітлюється іншими відповідями.
Містичний

Це насправді дуже погане рішення, оскільки воно створює СПІЛЬНИЙ СПИСОК. Ви нічого більше не зможете додати до контейнера.
Atais
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.