Дано:

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

Самый простой ответ это делать:

List list = Arrays.asList(array);

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

1. Список вернулись из asList имеет фиксированный размер. Поэтому, если вы хотите быть в состоянии добавить или удалить элементы из этого списка в вашем коде, вы'll необходимо, чтобы обернуть его в новый коллекции. В противном случае вы'll получить для себя возникновению unsupportedoperationexception`.
2. Список вернулись из asList() опирается на исходный массив. Если вы измените исходный массив, список будет изменен, а также. Это может быть удивительно.

<суп>(старый нить, но только 2 цента как никто не упоминал гуавы или других библиотек и некоторые другие детали) в</SUP-серфинг>

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

Это's стоит отметить гуава способом, что значительно упрощает эти махинации:

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

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

Используйте ImmutableList класс и и() и копия() методами фабрики <суп>(элементы могут'т быть null)</суп>:

List il = ImmutableList.of("string", "elements");  // from varargs
List il = ImmutableList.copyOf(aStringArray);      // from array

Для Изменяемых Список

Используйтесписки]4 класс и newArrayList() методы фабрики:

List l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List l2 = Lists.newArrayList(aStringArray);               // from array
List l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

Также обратите внимание на аналогичные методы для других структур данных в другие классы, например, в наборы.

Почему Гуавы?

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

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

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

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

Используйте версию JDK'ы массивы класс и asList() метод фабрики, завернутый с коллекции .unmodifiableList():

List l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

Обратите внимание, что возвращаемый тип для asList()являетсясписокс помощью осуществления конкретнойколлекции, но **не**Ява.утиль.Класса ArrayList. Это'с внутренним типом, который эмулируетколлекции`, но на самом деле напрямую ссылается на массив и делает ее "писать" По (изменения отражены в массиве).

Он запрещает изменения через некоторые из списка АПИ'ы методов путем простого расширения AbstractList (таким образом, добавляя или удаляя элементы не поддерживаются), но позволяет делать звонки набор () переопределять элементы. Таким образом, этот список вовсе'т-настоящему непреложное и в asList () должны быть обмотаны коллекций.unmodifiableList().

Увидеть следующий шаг, если вам нужен изменяемый список.

Для изменяемых список

Как и выше, но завернутый с Ява.утиль.Класса ArrayList:

List l1  = new ArrayList(Arrays.asList(array));    // Java 1.5 to 1.6
List l1b = new ArrayList(Arrays.asList(array));          // Java 1.7+
List l2  = new ArrayList(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List l2b = new ArrayList(Arrays.asList("a", "b"));       // Java 1.7+

Для образовательных целей: хороший ol' ручным способом

// for Java 1.5+
static  List arrayToList(final T[] array) {
  final List l = new ArrayList(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 arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

Начиная с Java 5, `массивы.asList () принимает параметр varargs и вы Don'т иметь, чтобы явно построить массив.

new ArrayList(Arrays.asList(myArray));

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

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

Collections.addAll(arraylist, array);

Ява 9

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

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

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

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

Сеп 269: удобство метода фабрики для коллекций

Сеп 269 приводятся некоторые удобные методы фабрики для коллекций Java интерфейс API. Эти неизменные статические методы фабрики построены в "список", С и "карта" интерфейсы в Java 9 и позже.

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

List arraylist = Arrays.asList(array);

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

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

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

List list = Stream.of(myArray).collect(Collectors.toList());

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

new ArrayList(Arrays.asList(myArray));

вы мая создать и заполнить два списка ! Заполняя два раза большой список-это именно то, что вы Don'т хотите, чтобы сделать, потому что будет создан еще один объект[]` массив каждый раз, когда возможностей должен быть продлен.

К счастью, реализация JDK-это массивы и быстро.asList(а[]) очень хорошо сделано. Это создать некую коллекцию именованных массивов.Класса ArrayList, где объект[] точек данных непосредственно в массив.

// in Arrays
@SafeVarargs
public static  List asList(T... a) {
    return new ArrayList(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

Опасная сторона заключается в том, что если вы измените исходный массив, вы измените список ! Вы уверены, что хотите этого ? Может да, а может нет.

Если нет, наиболее понятный способ сделать это :

ArrayList list = new ArrayList(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

Или как сказал @glglgl, вы можете создать другой независимый коллекции с :

new ArrayList(Arrays.asList(myArray));

Я люблю использовать "коллекции", массивы, или гуава. Но если это не'т подходят, или вы не'т чувствую это, просто написать еще один безвкусный линии вместо.

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

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

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

ArrayList arraylist = new ArrayList(Arrays.asList(array));

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

List arraylist = Arrays.asList(array);

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

1. Список<элемент> Список = массивов.asList(массив);

2. Список<элемент> Список = новый ArrayList(); Коллекции.методы addall(список, массив);

3. Список класса ArrayList = новый ArrayList(); список.методы addall(массивов.asList(массив));`

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

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

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

и общий новейший способ, чтобы создать массив observableArrays

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

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

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

то есть по данным Оракул документы

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

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

также в Java 9 Это's немного проще:

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

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

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

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

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

1. Если мы видим определение массивов.asList (метод) - вы получите нечто подобное:

открытые статические и л;т> Список<Т> asList(т а) //с varargs имеют тип T.

Таким образом, вы можете инициализировать коллекции, как это:

Список<элемент> класса ArrayList = массивов.asList(новый элемент(1) новый элемент(2) новый элемент(3));

* Примечание: каждый новый элемент(инт аргументы) будет рассматриваться как отдельный объект и может быть передан как ВАР-аргументы.

2. Там может быть другой ответ на этот вопрос тоже. Если вы видите объявление на Яве.утиль.Коллекции.метод методы addall () - вы получите нечто подобное:

публичный статический <П> логические методы addall(коллекция<? супер Т> с, т... а); Итак, этот код тоже полезно это делать

Коллекции.методы addall(ArrayList, в массиве);

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

ArrayList list = new ArrayList();

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

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

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