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

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

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

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

ArrayList<Element> arraylist = ???;

30 ответов


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

дано:

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

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

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

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

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

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

использовать ImmutableList класса и его of() и copyOf() методы фабрики (элементы не могут быть null):

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

он запрещает модификации через некоторые из 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);
}

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

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

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


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

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


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

Collections.addAll(arraylist, array);

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

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

Java 9

на Java 9, вы можете использовать List.of статический метод фабрики, чтобы создать List литерал. Что-то вроде следующего:

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

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

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

JEP 269: Удобство заводских методов для коллекций

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

чтобы преобразовать массив в ArrayList, разработчики часто делают следующее:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() вернет ArrayList, который является private static class inside Arrays, это не java.утиль.класс ArrayList. The java.util.Arrays.ArrayList класс set(), get(), contains() методы, но не имеет никаких методов для добавления элементов, поэтому ее размер фиксированный. Чтобы создать настоящий ArrayList, вы должны сделать:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

конструктор ArrayList может принять тип Collection, который также Супер тип для java.util.Arrays.ArrayList


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

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


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

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

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

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

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

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

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

вы можете конвертировать с помощью различных методов

  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


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

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

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

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

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

как все сказали, что это не так

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

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

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

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

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

, что согласно Oracle Docs

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

Обновить Java 9

также в Java 9 это немного просто:

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

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

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

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

дано:

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

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

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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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

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