У меня есть массив, который инициализирован как:

Element[] array = {new Element(1), new Element(2), new Element(3)};

Я хотел бы преобразовать этот массив в объект ArrayList класс.

ArrayList<Element> arraylist = ???;
3906
Ron Tuffin 1 Окт 2008 в 18:38
56
В Java9 -> List list = List.of («Привет», «Мир», «от», «Java»);
 – 
MarekM
11 Апр 2017 в 15:18
27
Этот ответ неверен, поскольку он не возвращает ArrayList. Плакат просил именно об этом.
 – 
Dorian Gray
12 Окт 2017 в 09:28
5
Я думаю, что он не использовал интерфейс List, потому что это лучшая практика. Но если хотите, вот - новый ArrayList <> (List.of («Hello», «World», «from», «Java»));
 – 
MarekM
17 Окт 2017 в 15:09
19
Дело не в использовании интерфейса, а в том, что в вашем решении возвращаемый список не подлежит изменению. Это может быть больше проблемой, и причина, по которой он попросил ArrayList
 – 
Dorian Gray
3 Авг 2018 в 23:59

30 ответов

Лучший ответ
new ArrayList<>(Arrays.asList(array));
4827
iota 18 Фев 2020 в 04:53
384
Ага. И в (наиболее распространенном) случае, когда вам нужен просто список, вызов new ArrayList также не нужен.
 – 
Calum
1 Окт 2008 в 18:41
152
- просто используйте List<ClassName> list = Arrays.asList(array)
 – 
Pool
29 Июн 2011 в 19:18
264
И @Pool - как указано ниже в ответе Алекса Миллера, использование Arrays.asList(array) без передачи его в новый объект ArrayList исправит размер списка. Одна из наиболее распространенных причин использования ArrayList - это возможность динамически изменять его размер, и ваше предложение предотвратит это.
 – 
Code Jockey
26 Сен 2011 в 23:04
142
Arrays.asList () - ужасная функция, и вы никогда не должны просто использовать ее возвращаемое значение как есть. Он нарушает шаблон списка, поэтому всегда используйте его в указанной здесь форме, даже если он кажется избыточным. Хороший ответ.
 – 
Adam
23 Янв 2013 в 07:28
87
Пожалуйста, изучите javadoc для java.util.List. Контракт на добавление позволяет им генерировать исключение UnsupportedOperationException. docs.oracle.com/ javase / 7 / docs / api / java / util /… По общему признанию, с объектно-ориентированной точки зрения не очень хорошо, что много раз вам нужно знать конкретную реализацию, чтобы использовать коллекцию - это было прагматичный выбор дизайна, чтобы структура оставалась простой.
 – 
lbalazscs
22 Фев 2013 в 13:41

(старый поток, но всего 2 цента, так как ни один не упоминает Guava или другие библиотеки и некоторые другие детали)

Если можете, используйте гуаву

Стоит указать на способ Guava, который значительно упрощает эти махинации:

Применение

Для неизменяемого списка

Используйте ImmutableList и его of() и copyOf() фабричные методы (элементы не могут быть нулевыми) :

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

Для изменяемого списка

Используйте Lists и его newArrayList() заводские методы:

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

Также обратите внимание на аналогичные методы для других структур данных в других классах, например, в Sets.

Почему гуава?

Основная привлекательность может заключаться в уменьшении беспорядка из-за универсальных шаблонов для обеспечения безопасности типов, таких как использование Guava фабричные методы позволяют определять типы большую часть времени. Однако этот аргумент не имеет смысла, поскольку в Java 7 появился новый алмазный оператор.

Но это не единственная причина (и Java 7 еще не везде): сокращенный синтаксис также очень удобен, а инициализаторы методов, как показано выше, позволяют писать более выразительный код. Вы делаете в одном вызове Guava то, что занимает 2 с текущими коллекциями Java.


Если ты не можешь ...

Для неизменяемого списка

Используйте класс JDK Arrays в JDK. и его asList() фабричный метод, заключенный в Collections.unmodifiableList():

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

Обратите внимание, что возвращаемый тип для asList() - это List, использующий конкретную реализацию ArrayList, но это НЕ java.util.ArrayList. Это внутренний тип, который имитирует ArrayList, но на самом деле напрямую ссылается на переданный массив и делает его "сквозным" (изменения отражаются в массиве).

Он запрещает модификацию некоторых методов List API путем простого расширения AbstractList (поэтому добавление или удаление элементов не поддерживается), однако разрешает вызовы set() для переопределения элементов. Таким образом, этот список не является действительно неизменным, и вызов asList() должен быть заключен в Collections.unmodifiableList().

См. Следующий шаг, если вам нужен изменяемый список.

Для изменяемого списка

То же, что и выше, но с фактическим java.util.ArrayList:

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

В образовательных целях: старый добрый ручной способ

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}
364
Konstantin Gerasimov 13 Дек 2016 в 20:02
30
+1 Но обратите внимание, что List, возвращаемый Arrays.asList, является изменяемым в том смысле, что вы все еще можете элементы set - его просто нельзя изменить размер. Для неизменяемых списков без Guava вы можете указать Collections.unmodifiableList.
 – 
Paul Bellora
10 Янв 2013 в 06:54
2
В вашем разделе Для образовательных целей: старый добрый ручной способ ваш arrayToList для Java 1.5+ неверен. Вы создаете списки String и пытаетесь получить строки из заданного массива вместо использования универсального типа параметра, T. Кроме этого, хороший ответ и +1 за то, что он единственный, включая ручной способ.
 – 
afsantos
16 Май 2013 в 17:41
1
Я бы переименовал ваш раздел «Если вы не можете ... / Для неизменяемого списка» на «Для немодифицируемого списка», поскольку он может быть изменен более поздними изменениями в обернутом массиве. Это все еще O(1), но для неизменности вы должны сделать копию, например, с помощью Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array))).
 – 
maaartinus
19 Ноя 2019 в 12:35
Вы не должны использовать стороннюю библиотеку, если в java есть жизнеспособные альтернативы. Причины: вы увеличиваете вероятность ошибок, внесенных сторонней библиотекой, вы увеличиваете площадь атаки для потенциальных хакеров. Сама гуава слишком спроектирована.
 – 
marathon
1 Май 2021 в 21:04
1
@marathon: Все справедливые баллы (+1), но: a / Этому ответу 9 лет (ах!), поэтому имейте в виду, что с тех пор все немного изменилось. В то время Java 8 была только на горизонте. б / Во многих случаях хорошая библиотека, вероятно, будет содержать меньше ошибок, чем ваш собственный код, так как она выиграет от большего количества глазных яблок, которые можно было бы выбрать во всех своих струпьях. c / Guava не такой уж и тяжелый, и я бы не назвал его чрезмерно сложным. Он довольно хорошо спроектирован и прост, но это правда, что вам может не понадобиться все это. d / Я предоставил ванильный способ Java (конечно, для Java того времени), так как я также согласен, что библиотека не всегда нужна.
 – 
haylem
14 Май 2021 в 11:56

Поскольку этот вопрос довольно старый, меня удивляет, что никто еще не предложил простейшую форму:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

Начиная с Java 5, Arrays.asList() принимает параметр varargs, и вам не нужно явно создавать массив.

242
Andrii Abramov 29 Сен 2016 в 19:25
8
В частности, List<String> a = Arrays.asList("first","second","third")
 – 
18446744073709551615
12 Июл 2016 в 18:29
new ArrayList<T>(Arrays.asList(myArray));

Убедитесь, что myArray того же типа, что и T. Вы получите ошибку компилятора, если попытаетесь создать List<Integer>, например, из массива int.

219
Bill the Lizard 13 Фев 2017 в 20:04
В случае от int до List<Integer>: List<Integer> ILst = Arrays.stream( myarray ).boxed().collect(Collectors.toList());
 – 
Abdelmonem Mahmoud Amer
2 Май 2021 в 11:16

Другой способ (хотя по сути эквивалентен решению new ArrayList(Arrays.asList(array)) по производительности:

Collections.addAll(arraylist, array);
108
Peter Tseng 4 Апр 2012 в 03:28

Java 9

В Java 9 можно использовать List.of статический фабричный метод для создания List буквальный. Примерно так:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

Это вернет неизменяемый список, содержащий три элемента. Если вам нужен изменяемый список, передайте этот список конструктору ArrayList:

new ArrayList<>(List.of(// elements vararg))

JEP 269: методы фабрики удобства для коллекций

JEP 269 предоставляет некоторые удобные фабричные методы для Java Collections API. Эти неизменяемые статические фабричные методы встроены в List, Set и Map интерфейсы в Java 9 и новее.

105
Community 20 Июн 2020 в 12:12
1
List.of () не вернет экземпляр java.util.ArrayList, как запрошено в исходном вопросе. Следовательно, верным ответом является только второй вариант.
 – 
tquadrat
5 Июл 2019 в 15:31

Вероятно, вам нужен просто список, а не ArrayList. В этом случае вы можете просто сделать:

List<Element> arraylist = Arrays.asList(array);
88
Kip 1 Окт 2008 в 18:45
8
Это будет поддержано исходным входным массивом, поэтому вы (вероятно) захотите обернуть его в новый список ArrayList.
 – 
Bill the Lizard
1 Окт 2008 в 18:46
16
Будьте осторожны с этим раствором. Если вы посмотрите, Arrays НЕ возвращает истинный java.util.ArrayList. Он возвращает внутренний класс, реализующий требуемые методы, но вы не можете изменить участников в списке. Это просто оболочка вокруг массива.
 – 
Mikezx6r
1 Окт 2008 в 18:47
1
Вы можете преобразовать элемент List в ArrayList
 – 
monksy
10 Окт 2009 в 02:48
12
@ Mikezx6r: небольшое исправление : это список фиксированного размера. Вы можете изменить элементы списка (метод set), вы не можете изменить размер списка (не элементы add или remove)!
 – 
user85421
4 Дек 2009 в 16:10
1
Да, с оговоркой, что это зависит от того, что вы хотите делать со списком. Стоит отметить, что если OP просто хочет перебирать элементы, массив вообще не нужно преобразовывать.
 – 
PaulMurrayCbr
5 Май 2013 в 13:23

Еще одно обновление, почти заканчивающееся в 2014 году, вы можете сделать это и с Java 8:

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

Было бы сохранено несколько символов, если бы это был просто List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());
73
yamilmedina 25 Ноя 2014 в 23:48
8
Вероятно, лучше не зависеть от реализации, но Collectors.toList() фактически возвращает ArrayList.
 – 
bcsb1001
31 Дек 2014 в 22:55
Некорректное использование Stream.of (...); это создаст одноэлементный поток. Вместо этого используйте Arrays.stream
 – 
Patrick Parker
18 Ноя 2016 в 14:59
Я так не думаю, 2 варианта действительны, но Arrays.stream немного «лучше», так как вы можете создать его с фиксированным размером, используя метод перегрузки с аргументами start, end. См. Также: stackoverflow.com/a/27888447/2619091
 – 
yamilmedina
1 Дек 2016 в 00:45

Если вы используете:

new ArrayList<T>(Arrays.asList(myArray));

Вы можете создать и заполнить два списка! Дважды заполнять большой список - это именно то, чего вы не хотите, потому что он будет создавать новый массив Object[] каждый раз, когда необходимо увеличить емкость.

К счастью, реализация JDK выполняется быстро, а Arrays.asList(a[]) выполнен очень хорошо. Он создает своего рода ArrayList с именем Arrays.ArrayList, где данные Object [] указывают непосредственно на массив.

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

Опасная сторона состоит в том, что если вы измените исходный массив, вы измените список! Вы уверены, что хотите этого? Может да может нет.

Если нет, то наиболее понятный способ сделать это:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

Или, как сказал @glglgl, вы можете создать еще один независимый ArrayList с помощью:

new ArrayList<T>(Arrays.asList(myArray));

Я люблю использовать Collections, Arrays или гуаву. Но если это не подходит или вы этого не чувствуете, просто напишите вместо этого другую неэлегантную строку.

46
Nicolas Zozol 29 Июн 2016 в 22:22
1
Я не вижу фундаментальной разницы между вашим циклом в конце ответа и частью new ArrayList<T>(Arrays.asList(myArray));, которую вы не поощряете использовать. Оба делают одно и то же и имеют одинаковую сложность.
 – 
glglgl
22 Фев 2015 в 20:03
Коллекции создают указатель в начале массива. Мой цикл создает много указателей: по одному на каждый член массива. Поэтому, если исходный массив изменится, мои указатели по-прежнему будут направлены на прежние значения.
 – 
Nicolas Zozol
22 Фев 2015 в 22:59
1
new ArrayList<T>(Arrays.asList(myArray)); делает то же самое, он копирует asList в ArrayList ...
 – 
glglgl
23 Фев 2015 в 00:56

В Java 9 вы можете использовать:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
40
Vishal Yadav 12 Авг 2017 в 14:22
Обратите внимание, что это не ArrayList, как было явно задано.
 – 
Dorian Gray
3 Авг 2018 в 23:57

Согласно вопросу, ответ с использованием java 1.7:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

Однако лучше всегда использовать интерфейс:

List<Element> arraylist = Arrays.<Element>asList(array);
36
nekperu15739 18 Май 2015 в 01:07
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
33
Bohdan 7 Янв 2014 в 10:04

Вы можете конвертировать разными способами

  1. List<Element> list = Arrays.asList(array);

  2. List list = new ArrayList ();
    Collections.addAll (список, массив);

  3. Список Arraylist = новый Arraylist ();
    list.addAll (Arrays.asList (массив));

Для получения дополнительных сведений см. http: // javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

25
Draken 18 Июн 2016 в 19:30

Начиная с Java 8, есть более простой способ преобразования:

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

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}
25
Andrii Abramov 16 Июн 2020 в 11:17

Как все сказали, это будет так

 new ArrayList<>(Arrays.asList("1","2","3","4"));

А самый распространенный способ создания массива - observableArrays

ObservableList: список, который позволяет слушателям отслеживать изменения, когда они происходят.

Для Java SE вы можете попробовать

FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));

То есть согласно Oracle Docs

observableArrayList () Создает новый пустой наблюдаемый список, поддерживаемый arrayylist. observableArrayList (E ... items) Создает новый список наблюдаемых массивов с добавленными в него элементами.

Обновите Java 9

Также в Java 9 это немного проще:

List<String> list = List.of("element 1", "element 2", "element 3");
24
jemystack 5 Дек 2018 в 15:26

Другой простой способ - добавить все элементы из массива в новый список ArrayList, используя цикл for-each.

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);
12
spencer.sm 16 Дек 2015 в 23:32

Если массив имеет примитивный тип, данные ответы не будут работать. Но начиная с Java 8 вы можете использовать:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
12
Unheilig 10 Июл 2017 в 05:37
Это решение тоже не работает с массивом char.
 – 
PixelMaster
10 Июн 2018 в 22:55

Несмотря на то, что на этот вопрос есть много прекрасно написанных ответов, я добавлю свои комментарии.

Скажем, у вас есть Element[] array = { new Element(1), new Element(2), new Element(3) };

Новый список ArrayList можно создать следующими способами

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

И они очень хорошо поддерживают все операции ArrayList.

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

Но следующие операции возвращают только представление списка ArrayList, а не фактический ArrayList.

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

Следовательно, они выдадут ошибку при попытке выполнить некоторые операции с ArrayList.

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

Подробнее о представлении массива в виде списка ссылка.

9
Community 23 Май 2017 в 15:26

Самый простой способ сделать это - добавить следующий код. Испытано и протестировано.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));
9
Hemin 3 Май 2017 в 11:38

Мы можем легко преобразовать массив в ArrayList. Мы используем метод addAll() интерфейса Collection для копирования содержимого из одного списка в другой.

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));
9
Andrii Abramov 18 Мар 2018 в 22:15
Это менее эффективно, чем принятый ответ 9-летней давности.
 – 
charles-allen
10 Июл 2017 в 13:06
2
Один из конструкторов ArrayList принимает аргумент ? extends Collection<T>, что делает вызов addAll избыточным.
 – 
Tamoghna Chowdhury
6 Окт 2017 в 23:26

Используйте следующий код для преобразования массива элементов в ArrayList.

Element[] array = {new Element(1), new Element(2), new Element(3)};

ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
    elementArray.add(array[i]);
}
9
Pang 16 Янв 2019 в 03:50

Данный массив объектов:

Element[] array = {new Element(1), new Element(2), new Element(3) , new Element(2)};

Преобразовать массив в список:

    List<Element> list = Arrays.stream(array).collect(Collectors.toList());

Преобразовать массив в ArrayList

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

Преобразовать массив в LinkedList

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

Список печати:

    list.forEach(element -> {
        System.out.println(element.i);
    });

ВЫХОД

1

2

3

7
Arpan Saini 7 Сен 2019 в 23:36

Уже все дали достаточно хороший ответ на вашу проблему. Теперь из всех предложений вам нужно решить, какой из них будет соответствовать вашим требованиям. Вам нужно знать два типа сбора. Одна - немодифицированная коллекция, а другая - одна коллекция, которая позволит вам изменить объект позже.

Итак, здесь я приведу короткий пример для двух случаев использования.

  • Создание неизменяемой коллекции :: Если вы не хотите изменять объект коллекции после создания

    List<Element> elementList = Arrays.asList(array)

  • Создание изменяемой коллекции :: Когда вы можете захотеть изменить созданный объект коллекции после создания.

    List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));

6
Sumit Das 25 Июл 2017 в 09:03
List elementList = Arrays.asList (array) создает оболочку над исходным массивом, которая делает исходный массив доступным как List. Следовательно, создается объект-оболочка, ничего не копируется из исходного массива. Следовательно, такие операции, как добавление или удаление элементов, не разрешены.
 – 
Priyanka
9 Сен 2017 в 11:57
4
Обратите внимание, что ваша "неизменяемая коллекция" на самом деле не является неизменной - List, возвращаемый Arrays.asList, является просто оболочкой над исходным массивом и позволяет получать доступ к отдельным элементам и изменять их через get и set. Вам, вероятно, следует пояснить, что вы имеете в виду «не добавлять и не удалять элементы» вместо «неизменяемый», что означает не изменять вообще.
 – 
Tamoghna Chowdhury
6 Окт 2017 в 23:24

Класс Arrays в Java 8 предоставляет метод stream (), который имеет перегруженные версии, принимающие как примитивные массивы, так и массивы объектов.

/**** Converting a Primitive 'int' Array to List ****/

int intArray[] = {1, 2, 3, 4, 5};

List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());

/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/

List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());

/**** Converting an 'Integer' Array to List ****/

Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());
6
sanyassh 19 Май 2019 в 14:40

Код ниже кажется хорошим способом сделать это.

new ArrayList<T>(Arrays.asList(myArray));
5
Singh123 4 Дек 2019 в 10:59

Вы также можете сделать это с потоком в Java 8.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 
22
Vaseph 6 Фев 2016 в 11:56
3
Начиная с java 8 , Collectors.toList() возвращает ArrayList. Однако это может отличаться в будущих версиях на java. Если вам нужен определенный тип коллекции, используйте вместо этого Collectors.toCollection(), где вы можете указать, какой именно тип коллекции вы хотите создать.
 – 
Raja Anbazhagan
4 Фев 2019 в 14:08

Другое решение Java8 (возможно, я пропустил ответ среди большого набора. Если да, приношу свои извинения). Это создает ArrayList (в отличие от List), т.е. можно удалять элементы

package package org.something.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

Вывод ...
Привет
Мир

9
Toothless Seer 20 Июн 2017 в 11:40

Данный:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

Самый простой ответ - сделать:

List<Element> list = Arrays.asList(array);

Это будет работать нормально. Но некоторые предостережения:

  1. Список, возвращаемый из asList, имеет фиксированный размер . Итак, если вы хотите иметь возможность добавлять или удалять элементы из возвращенного списка в вашем коде, вам нужно обернуть его в новый ArrayList. В противном случае вы получите UnsupportedOperationException.
  2. Список, возвращаемый из asList(), поддерживается исходным массивом. Если вы измените исходный массив, список также будет изменен. Это может быть удивительно.
957
George Garchagudashvili 7 Ноя 2014 в 17:22
7
Какова временная сложность обеих операций? Я имею в виду с использованием явной конструкции Arraylist и без нее.
 – 
damned
23 Май 2012 в 06:17
40
Arrays.asList () просто создает ArrayList, обертывая существующий массив так, чтобы он был O (1).
 – 
Alex Miller
23 Май 2012 в 17:15
30
Заключение в новый ArrayList () приведет к тому, что все элементы списка фиксированного размера будут повторены и добавлены в новый ArrayList, то есть O (n).
 – 
Alex Miller
23 Май 2012 в 17:21
9
Реализация List, возвращаемого asList (), не реализует несколько методов List (например, add (), remove (), clear () и т. д.), что объясняет исключение UnsupportedOperationException. определенно предостережение ...
 – 
sethro
14 Ноя 2012 в 23:33
11
Когда в вопросе задается вопрос «объект класса ArrayList», я думаю, разумно предположить, что классом, на который он ссылается, является java.util.ArrayList. Arrays.asList фактически возвращает java.util.Arrays.ArrayList, который не является instanceof другим классом. Итак, третье предостережение: если вы попытаетесь использовать его в контексте, требующем вышеуказанного, это не сработает.
 – 
Dave L.
24 Июн 2016 в 22:16
  1. Если мы увидим определение метода Arrays.asList(), вы получите что-то вроде этого:

     public static <T> List<T> asList(T... a) //varargs are of T type. 
    

    Итак, вы можете инициализировать arraylist следующим образом:

     List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
    

    Примечание : каждый new Element(int args) будет рассматриваться как отдельный объект и может быть передан как var-args.

  2. На этот вопрос тоже может быть другой ответ.
    Если вы увидите объявление для метода java.util.Collections.addAll(), вы получите что-то вроде этого:

    public static <T> boolean addAll(Collection<? super T> c, T... a);
    

    Итак, этот код также полезен для этого

    Collections.addAll(arraylist, array);
    
17
Andrii Abramov 13 Мар 2020 в 11:51

Вы можете сделать это в java 8 следующим образом

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
9
Ron Tuffin 2 Авг 2017 в 17:03
2
Проголосовали против, потому что этот состав выглядит очень опасным. ничто не указывает на то, что тип возвращаемого списка на самом деле является ArrayList, как указано в javadoc: «Нет никаких гарантий относительно типа, изменчивости, сериализуемости или поточной безопасности возвращаемого списка»
 – 
Dorian Gray
3 Июл 2018 в 20:45
1
Если вы хотите явно создать ArrayList, попробуйте следующее: ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
 – 
Dorian Gray
3 Авг 2018 в 23:53