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

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

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

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

ArrayList<Element> arraylist = ???;
3118
задан Ron Tuffin 01 окт. '08 в 17:38
источник поделиться
35 ответов
  • 1
  • 2
new ArrayList<>(Arrays.asList(array))
4121
ответ дан Tom 01 окт. '08 в 17:39
источник поделиться

Дано:

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

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

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

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

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

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

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

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

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

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

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

179
ответ дан Bill the Lizard 01 окт. '08 в 17:40
источник поделиться

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

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

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 и более поздних версиях.

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

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

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

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

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

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

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

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

48
ответ дан Xar E Ahmer 25 июня '14 в 10:20
источник поделиться

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

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

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

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

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

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

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

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

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

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

  • 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

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

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

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

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

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 
13
ответ дан Vaseph 06 февр. '16 в 11:56
источник поделиться

поскольку все сказали, что это сделает это

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

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

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

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

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

это согласно Oracle Docs

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

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

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

List<String> list = List.of("element 1", "element 2", "element 3");
10
ответ дан Abojemyeg 05 янв. '17 в 21:32
источник поделиться
  • Если мы увидим определение метода 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);
    
10
ответ дан Vikrant Kashyap 30 марта '16 в 9:48
источник поделиться

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

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

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

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

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

Дано:

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

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

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

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

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

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

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

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

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> arraylist =Arrays.asList(array);
3
ответ дан Ibz.Shaikh 26 окт. '18 в 17:38
источник поделиться

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Это ваш массив элементов. Он может преобразовать в arraylist, используя эти строки кода.

Элемент [] array = {новый элемент (1), новый элемент (2), новый элемент (3)};

ArrayListelementArray = новый ArrayList(); для (int я = 0; я

elementArray.add(array[i]);

}

2
ответ дан TG Kavinda Pushpitha 03 дек. '18 в 14:32
источник поделиться
  • 1
  • 2

Другие вопросы по меткам или Задайте вопрос