дано:

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 цента, поскольку никто не упоминает гуаву или другие библиотеки и некоторые другие детали)}

Если Вы Можете, Используйте Гуава

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

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

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

использовать 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

In 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 с именем массивы.ArrayList, где объект [] данных указывает непосредственно на матрица.

// 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. наблюдатель (Е... предметы) Создает новый список наблюдаемых массивов с добавленными в него элементами.

Обновить 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)

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

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