Вопрос:

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

java arrays arraylist type-conversion

1335898 просмотра

30 ответа

22634 Репутация автора

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

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

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

ArrayList<Element> arraylist = ???;
Автор: Ron Tuffin Источник Размещён: 01.10.2008 02:38

Ответы (30)


4197 плюса

46047 Репутация автора

Решение
new ArrayList<>(Arrays.asList(array))
Автор: Tom Размещён: 01.10.2008 02:39

181 плюса

292989 Репутация автора

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

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

Автор: Bill the Lizard Размещён: 01.10.2008 02:40

65 плюса

66536 Репутация автора

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

List<Element> arraylist = Arrays.asList(array);
Автор: Kip Размещён: 01.10.2008 02:45

819 плюса

53651 Репутация автора

Дано:

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()поддерживается исходным массивом. Если вы измените исходный массив, список также будет изменен. Это может быть удивительно.
Автор: Alex Miller Размещён: 01.10.2008 03:39

210 плюса

47901 Репутация автора

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

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

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

Автор: Tim Büthe Размещён: 22.06.2011 11:30

83 плюса

9073 Репутация автора

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

Collections.addAll(arraylist, array);
Автор: Peter Tseng Размещён: 03.04.2012 11:20

310 плюса

19639 Репутация автора

(старая ветка, но всего 2 цента, так как никто не упоминает 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.

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

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

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


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

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

Используйте 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но на самом деле напрямую ссылается на переданный массив и заставляет его «проходить через» (изменения отражаются в массиве).

Он запрещает модификацию некоторых методов ListAPI путем простого расширения 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);
}
Автор: haylem Размещён: 16.11.2012 05:16

21 плюса

8987 Репутация автора

// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
Автор: Bohdan Размещён: 07.01.2014 06:04

31 плюса

4974 Репутация автора

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

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

Автор: Nicolas Zozol Размещён: 18.01.2014 01:01

56 плюса

1805 Репутация автора

Еще одно обновление, почти заканчивающееся 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.11.2014 08:48

25 плюса

1149 Репутация автора

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

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

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

List<Element> arraylist = Arrays.<Element>asList(array);
Автор: nekperu15739 Размещён: 17.05.2015 10:07

8 плюса

7223 Репутация автора

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

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

for(Element e : array)
    list.add(e);
Автор: spencer.sm Размещён: 16.12.2015 08:32

14 плюса

496 Репутация автора

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

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 
Автор: Vaseph Размещён: 06.02.2016 08:56

10 плюса

3534 Репутация автора

  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);
    
Автор: Vikrant Kashyap Размещён: 30.03.2016 06:48

72 плюса

26148 Репутация автора

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

Автор: Ali Dehghani Размещён: 17.04.2016 04:58

17 плюса

1039 Репутация автора

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

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

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

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

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

Автор: oxy_js Размещён: 02.05.2016 08:40

14 плюса

4226 Репутация автора

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

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}
Автор: Andrii Abramov Размещён: 23.12.2016 12:31

13 плюса

160 Репутация автора

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

 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");
Автор: Abojemyeg Размещён: 05.01.2017 06:32

4 плюса

2151 Репутация автора

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

Скажи у тебя 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

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

Автор: Devendra Lattu Размещён: 07.04.2017 06:45

28 плюса

715 Репутация автора

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

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
Автор: MarekM Размещён: 11.04.2017 12:20

5 плюса

181 Репутация автора

Дано:

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

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

List<Element> listArray = Arrays.asList(array);
Автор: Lakshan Размещён: 22.04.2017 03:53

3 плюса

444 Репутация автора

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

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));
Автор: Hemin Размещён: 03.05.2017 08:38

3 плюса

107 Репутация автора

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

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
Автор: Adit A. Pillai Размещён: 07.06.2017 12:14

0 плюса

382 Репутация автора

 Element[] array = {new Element(1), new Element(2), new Element(3)};
 List<Element> elements=Arrays.asList(array);
Автор: yousef Размещён: 11.06.2017 09:03

3 плюса

572 Репутация автора

Другое решение 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.06.2017 08:33

3 плюса

1145 Репутация автора

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

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));
Автор: rashedcs Размещён: 04.07.2017 07:22

6 плюса

550 Репутация автора

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

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
Автор: A1m Размещён: 10.07.2017 02:21

2 плюса

96 Репутация автора

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

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

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

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

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

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

Автор: Sumit Das Размещён: 25.07.2017 06:03

3 плюса

107 Репутация автора

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

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> arraylist =Arrays.asList(array);
Автор: Ibz.Shaikh Размещён: 26.10.2018 02:38

3 плюса

131 Репутация автора

Используйте следующий код для преобразования массива элементов в 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]);
}
Автор: TG Kavinda Pushpitha Размещён: 03.12.2018 11:32
Вопросы из категории :
32x32