Создать ArrayList из массива

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

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

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

ArrayList<Element> arraylist = ???;

Ответы

Ответ 1

new ArrayList<>(Arrays.asList(array))

Ответ 2

Дано:

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

Самый простой ответ:

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

Это будет работать нормально. Но некоторые оговорки:

Список, возвращенный из asList, имеет фиксированный размер. Таким образом, если вы хотите иметь возможность добавлять или удалять элементы из возвращаемого списка в вашем коде, вам необходимо обернуть его в новый ArrayList. В противном случае вы получите UnsupportedOperationException.
Список, возвращенный из asList(), поддерживается исходным массивом. Если вы измените исходный массив, список также будет изменен. Это может быть удивительно.

Ответ 3

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

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

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

Использование

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

Используйте ImmutableList класс и of() и copyOf() factory методы ^{(элементы не могут быть пустыми)}:

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

Для Mutable List

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

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?

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

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

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

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

Используйте класс JDK Arrays и его asList() factory, завернутый 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, но фактически напрямую ссылается на переданный массив и заставляет его "писать" (изменения отражены в массиве).

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

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

Для списка Mutable List

То же, что и выше, но обернуто фактическим 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);
}

Ответ 4

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

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

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

Ответ 5

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

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

Ответ 6

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

Collections.addAll(arraylist, array);

Ответ 7

Java 9

В Java 9 вы можете использовать List.of static factory для создания литерала 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 предоставляет некоторые удобные фабричные методы API Java Collections. Эти неизменные статические заводские методы встроены в интерфейсы List, Set и Map в Java 9 и более поздних версиях.

Ответ 8

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

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

Ответ 9

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

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

Несколько символов будут сохранены, если это может быть только List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());

Ответ 10

Чтобы преобразовать массив в ArrayList, разработчики часто делают это:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() вернет ArrayList, который является private static class inside Arrays, это не класс java.util.ArrayList. The java.util.Arrays.ArrayList класс имеет методы set(), get(), contains(), но не имеет методов для добавления элементов, поэтому его размер фиксирован. Чтобы создать реальный ArrayList, вы должны сделать:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

Конструктор ArrayList может принимать Тип коллекции, который также является супер-типом для java.util.Arrays.ArrayList

Ответ 11

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

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

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

Если нет, наиболее понятным способом является следующее:

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 или Guava. Но если это не подходит, или вы этого не чувствуете, просто напишите другую неэлегантную строку.

Ответ 12

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

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

Ответ 13

В соответствии с вопросом ответ с использованием java 1.7:

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

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

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

Ответ 14

// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray);

Ответ 15

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

List<Element> list = Arrays.asList(array);
List<Element> list = new ArrayList(); Collections.addAll(list, array);
Arraylist list = new Arraylist(); list.addAll(Arrays.asList(array));

Для более подробной информации вы можете обратиться к http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

Ответ 16

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

 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() Создает новый пустой список наблюдаемых, который поддерживается массивом. observableArrayList (E... items) Создает новый список наблюдаемых массивов с добавленными в него элементами.

Обновите Java 9

также в Java 9 это немного легко:

List<String> list = List.of("element 1", "element 2", "element 3");

Ответ 17

Поскольку Java 8 имеет более простой способ преобразования:

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}

Ответ 18

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

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

Ответ 19

Если мы увидим определение метода 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.
На этот вопрос может быть и другой ответ.
Если вы видите декларацию для метода java.util.Collections.addAll(), вы получите что-то вроде этого:
```
public static <T> boolean addAll(Collection<? super T> c, T... a);
```
Итак, этот код также полезен для этого
```
Collections.addAll(arraylist, array);
```

Ответ 20

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

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

for(Element e : array)
    list.add(e);

Ответ 21

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

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());

Ответ 22

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

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));

Ответ 23

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

Скажите, что у вас есть 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

Но следующие операции возвращают только представление List для 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

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

Ответ 24

Дано:

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

Использование:

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

Ответ 25

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

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

Ответ 26

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

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

Ответ 27

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

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

Выход... Привет, мир

Ответ 28

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

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

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

List<Element> elementList = Arrays.asList(array)
Создание мутируемых коллекций:: Когда вы захотите изменить созданный объект коллекции после создания.

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

Ответ 29

Вы можете сделать это легко с помощью массива Arrays.asList(arrayObj);

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

Ответ 30

Используйте следующий код для преобразования массива элементов в 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]);
}