it-swarm.com.ru

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

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

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

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

ArrayList<Element> arraylist = ???;
3198
Ron Tuffin
new ArrayList<>(Arrays.asList(array))
4212
Tom

Дано:

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

(старая ветка, но всего 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.


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

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

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

Он запрещает модификацию некоторых методов API List путем простого расширения 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);
}
311
haylem

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

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

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

210
Tim Büthe
new ArrayList<T>(Arrays.asList(myArray));

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

183
Bill the Lizard

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

Collections.addAll(arraylist, array);
83
Peter Tseng

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

72
Ali Dehghani

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

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

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

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

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

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

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

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

31
Nicolas Zozol

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

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

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

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

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

List<Element> arraylist = Arrays.<Element>asList(array);
25
nekperu15739
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
21
Bohdan

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

  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

17
oxy_js

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

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

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

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

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

 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");
14
Abojemyeg
  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);
    
10
Vikrant Kashyap

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

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

for(Element e : array)
    list.add(e);
8
spencer.sm

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

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

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

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

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

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

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

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

4
Devendra Lattu

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

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

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

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

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

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

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

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

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

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

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

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

2
Sumit Das

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

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

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

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

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

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

Класс Arrays в Java 8 предоставляет метод stream () с перегруженными версиями, принимающими как примитивные, так и объектные массивы.

/**** Converting a Primitive 'int' Array to List ****/

int intArray[] = {1, 2, 3, 4, 5};

List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());

/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/

List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());

/**** Converting an 'Integer' Array to List ****/

Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());
0
Himanshu Dave

Это четкий способ для этого

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