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

Question

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

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

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

ArrayList<Element> arraylist = ???;

Answer 1

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

Answer 2

Данный:

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() поддерживается исходным массивом.Если вы измените исходный массив, список также будет изменен.Это может быть удивительно.

Answer 3

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

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

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

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

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

Используйте 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.

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

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

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

---

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

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

Используйте JDK's Arrays класс и его 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);
}

Answer 4

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

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

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

Answer 5

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

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

Answer 6

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

Collections.addAll(arraylist, array);

Answer 7

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

Answer 8

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

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

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

Answer 10

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

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

Answer 11

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

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

Answer 12

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

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

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

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

Answer 13

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

Answer 14

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

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

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

3. Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));

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

Answer 15

как все уже говорили, это будет сделано так

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

и самый распространенный новейший способ создания массива - это Наблюдаемые массивы

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

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

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

это согласно Документы Oracle Docs

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

Обновление Java 9

кроме того, в Java 9 это немного проще:

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

Answer 16

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

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

Answer 17

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

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

Answer 18

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

Answer 19

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

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

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

Answer 20

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

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

Answer 21

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

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

Answer 22

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

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

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

Answer 23

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

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

Answer 24

Другое решение 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);
    }
}

Результат есть...
Здравствуйте
Мир

Answer 25

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

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

Answer 26

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

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

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

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

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

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

Answer 27

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

Answer 28

Вы можете создать ArrayList используя Какту (Я один из разработчиков):

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Нет никакой гарантии, что объект действительно будет принадлежать классу ArrayList.Если вам нужна такая гарантия, сделайте это:

ArrayList<String> list = new ArrayList<>(
  new StickyList<>(
    "Scott Fitzgerald", "Fyodor Dostoyevsky"
  )
);

Answer 29

Используйте приведенный ниже код

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

Answer 30

Это ясный способ для этого

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