Дано:

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

Самый простой ответ:

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

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

• Список, возвращенный из asList, имеет фиксированный размер. Таким образом, если вы хотите иметь возможность добавлять или удалять элементы из возвращаемого списка в вашем коде, вам необходимо обернуть его в новый ArrayList. В противном случае вы получите UnsupportedOperationException.
• Список, возвращенный из asList(), поддерживается исходным массивом. Если вы измените исходный массив, список также будет изменен. Это может быть удивительно.

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

Если вы можете, используйте Guava

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

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

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

Используйте ImmutableList класс и of() и copyOf() factory методы ^{(элементы не могут быть пустыми)}:

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

Для Mutable List

Используйте класс Lists и его newArrayList() factory:

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.

Почему Guava?

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

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

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

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

Используйте класс JDK Arrays и его asList() factory, завернутый 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().

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

Для списка Mutable List

То же, что и выше, но обернуто фактическим 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);

Java 9

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

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

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

Еще одно обновление, почти закончившееся в 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.util.ArrayList. The java.util.Arrays.ArrayList класс имеет методы set(), get(), contains(), но не имеет методов для добавления элементов, поэтому его размер фиксирован. Чтобы создать реальный ArrayList, вы должны сделать:

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

Конструктор ArrayList может принимать Тип коллекции, который также является супер-типом для 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
    }
    ....
}

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

Если нет, наиболее понятным способом является следующее:

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

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

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

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

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

• Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));

Для более подробной информации вы можете обратиться к 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));

то есть согласно Oracle Docs

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

Обновите Java 9

также в Java 9 это немного легко:

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

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

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

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

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

• Если мы увидим определение метода 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.

• На этот вопрос может быть и другой ответ.
  Если вы видите декларацию для метода java.util.Collections.addAll(), вы получите что-то вроде этого:

  public static <T> boolean addAll(Collection<? super T> c, T... a);
  

  Итак, этот код также полезен для этого

  Collections.addAll(arraylist, array);
  

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

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

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

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

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

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

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

Дано:

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

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

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

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

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

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

Но следующие операции возвращают только представление List для 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

List[]<String> arraylist=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"
  )
);

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

попробуйте это...

List<ObjectName> list = Arrays.asList(array) 

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

static final ArrayList<Element> myList = generateMyList();

private static ArrayList<Element> generateMyList() {
  final ArrayList<Element> result = new ArrayList<>();
  result.add(new Element(1));
  result.add(new Element(2));
  result.add(new Element(3));
  result.add(new Element(4));
  return result;
}

Преимущество использования этого шаблона состоит в том, что этот список генерируется очень интуитивно, поэтому его очень легко модифицировать даже с большими списками или сложной инициализацией, а с другой стороны всегда содержит те же элементы при каждом фактическом прогоне программы ( если вы не измените его позже).