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

2660
голосов

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

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

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

ArrayList<Element> arraylist = ???;
задан Ron Tuffin 01 окт. '08 в 17:38
источник

32 ответов

  • 1
  • 2
3607
голосов
new ArrayList<>(Arrays.asList(array))
ответ дан Tom 01 окт. '08 в 17:39
источник
710
голосов

Дано:

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

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

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

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

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

(старый поток, но всего 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);
}
ответ дан haylem 16 нояб. '12 в 20:16
источник
185
голосов

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

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

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

ответ дан Tim Büthe 22 июня '11 в 14:30
источник
161
голос
new ArrayList<T>(Arrays.asList(myArray));

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

ответ дан Bill the Lizard 01 окт. '08 в 17:40
источник
65
голосов

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

Collections.addAll(arraylist, array);
ответ дан Peter Tseng 04 апр. '12 в 2:20
источник
51
голос

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

List<Element> arraylist = Arrays.asList(array);
ответ дан Kip 01 окт. '08 в 17:45
источник
44
голосов

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

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

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

List<Element> list = Stream.of(myArray).collect(Collectors.toList());
ответ дан whyem 25 нояб. '14 в 23:48
источник
39
голосов

Чтобы преобразовать массив в 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

ответ дан Nepster 25 июня '14 в 10:20
источник
36
голосов

Java 9

В Java 9 вы можете использовать метод List.of static factory, чтобы создать a List. Что-то вроде следующего:

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

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

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

JEP 269: Удобство factory Методы коллекций

JEP 269 предоставляет некоторые удобные методы factory для API коллекций. Эти методы factory не находятся в текущей версии Java, которая составляет 8, но планируются для выпуска Java 9. Вы можете попробовать эту функцию, используя JDK 9 Early Access.

ответ дан Ali Dehghani 17 апр. '16 в 19:58
источник
25
голосов

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

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

ответ дан Nicolas Zozol 18 янв. '14 в 16:01
источник
19
голосов

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

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

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

List<Element> arraylist = Arrays.<Element>asList(array);
ответ дан nekperu15739 18 мая '15 в 1:07
источник
16
голосов
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
ответ дан Bohdan 07 янв. '14 в 9:04
источник
13
голосов

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

  • 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

ответ дан oxy_js 02 мая '16 в 11:40
источник
13
голосов

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

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
ответ дан MarekM 11 апр. '17 в 15:20
источник
10
голосов

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

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 
ответ дан Vaseph 06 февр. '16 в 11:56
источник
8
голосов
  • Если мы увидим определение метода 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);
    
ответ дан Vikrant Kashyap 30 марта '16 в 9:48
источник
6
голосов

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

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}
ответ дан Andrii Abramov 23 дек. '16 в 15:31
источник
5
голосов

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

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

for(Element e : array)
    list.add(e);
ответ дан spencer.sm 16 дек. '15 в 23:32
источник
4
голосов

Дано:

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

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

List<Element> listArray = Arrays.asList(array);
ответ дан Lakshan 22 апр. '17 в 6:53
источник
4
голосов

а общий новейший способ создания массива - наблюдаемые массивы

таким образом, ответ

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

что соответствует Oracle Docs

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

ответ дан Abojemyeg 05 янв. '17 в 21:32
источник
3
голосов

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

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

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

ответ дан Devendra Lattu 07 апр. '17 в 21:45
источник
1
голос

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

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
ответ дан Adit A. Pillai 07 июня '17 в 15:14
источник
1
голос

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

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));
ответ дан rashedcs 04 июля '17 в 10:22
источник
1
голос

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

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

ответ дан Toothless Seer 20 июня '17 в 11:33
источник
1
голос

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

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
ответ дан A1m 10 июля '17 в 5:21
источник
1
голос

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

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

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

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

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

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

ответ дан Sumit Das 25 июля '17 в 9:03
источник
1
голос

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

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));
ответ дан Hemin 03 мая '17 в 11:38
источник
0
голосов

Вы можете создать ArrayList с помощью Cactoos (я один из разработчиков):

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

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

ArrayList<String> list = new ArrayList<>(
  new StickyList<>(
    "Scott Fitzgerald", "Fyodor Dostoyevsky"
  )
);
ответ дан yegor256 26 июня '17 в 15:19
источник
0
голосов
 Element[] array = {new Element(1), new Element(2), new Element(3)};
 List<Element> elements=Arrays.asList(array);
ответ дан yousef 11 июня '17 в 12:03
источник
  • 1
  • 2

Другие вопросы по меткам