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

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

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

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

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

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

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

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

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

Collections.addAll(arraylist, array);

^{(old thread, but just 2 cents as none mention Guava or other libs and some other details)}

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

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

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

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

Используйте класс ImmutableList и его заводские методы of() и copyOf()^{(elements can't be 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.

Почему гуава?

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

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

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

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

Используйте класс Arrays JDK и его фабричный метод 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);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 List<Element> elements = Arrays.stream(array).collect(Collectors.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));
   

   Note : each new Element(int args) will be treated as Individual Object and can be passed as a var-args.

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

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

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

   Collections.addAll(arraylist, array);
   

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

Вы можете конвертировать разными способами

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, есть более простой способ преобразования:

import java.util.List;    
import static java.util.stream.Collectors.toList;

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

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

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

и самый распространенный способ создания массива - observableArrays

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

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

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

то есть согласно Документы Oracle

observableArrayList() Creates a new empty observable list that is backed by an arraylist. observableArrayList(E... items) Creates a new observable array list with items added to it.

Обновите Java 9

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

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

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

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

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

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

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

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

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

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

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

Another Java8 solution (I may have missed the answer among the large set. If so, my apologies). This creates an ArrayList (as opposed to a List) i.e. one can delete elements

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  List<Element> elementList = new ArrayList<Element>(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<Element> list = (ArrayList) Arrays.asList(array);

Класс 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());

лямбда-выражение, которое генерирует список типаArrayList<Element>
(1) без непроверенного приведения
(2) без создания второго списка (например, asList())

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

Данный массив объектов:

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

Преобразовать массив в список:

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

Преобразовать массив в ArrayList

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

Преобразовать массив в LinkedList

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

Список печати:

    list.forEach(element -> {
        System.out.println(element.i);
    });

ВЫХОД

1

2

3

Код ниже кажется хорошим способом сделать это.

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

Это первый и самый простой способ

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

Другой способ

//declare myarray
ArrayList <String> ar = new ArrayList<String> ();
for(String s : myArray){
    ar.add(s);
}

Это итерация по массиву и добавление каждого элемента отдельно

Тип используемого здесь цикла for называется улучшенным циклом for.

Привет, вы можете использовать этот line of code, и это самый простой способ

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

или, если вы используете Java 9, вы также можете использовать этот метод:

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

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

Object[] myNum = {10, 20, 30, 40};
List<Object> newArr = new ArrayList<>(Arrays.asList(myNum));

В java есть в основном 3 метода для преобразования множество в arrayList

1. Использование метода Arrays.asList (): передайте требуемый массив этому методу, получите объект List и передайте его в качестве параметра конструктору класса ArrayList.

   List<String> list = Arrays.asList(array);                   
   System.out.println(list);
   

2. Метод Collections.addAll () - создайте новый список перед использованием этого метода, а затем добавьте элементы массива с помощью этого метода в существующий список.

    List<String> list1 = new ArrayList<String>();
    Collections.addAll(list1, array);
    System.out.println(list1);
   

3. Метод итерации - Создайте новый список. Итерируйте массив и добавьте каждый элемент в список.

    List<String> list2 = new ArrayList<String>();
    for(String text:array) {
        list2.add(text);
    }
    System.out.println(list2);
   

вы также можете сослаться на этот документ

Вы можете использовать следующие 3 способа создания ArrayList из массива.

  String[] array = {"a", "b", "c", "d", "e"};

  //Method 1
  List<String> list = Arrays.asList(array);          

  //Method 2
  List<String> list1 = new ArrayList<String>();
  Collections.addAll(list1, array);

  //Method 3
  List<String> list2 = new ArrayList<String>();
  for(String text:array) {
     list2.add(text);
  }

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

Это показано ниже.

public static void main(String[] args) {
        String[] array = {new String("David"), new String("John"), new String("Mike")};

        ArrayList<String> theArrayList = convertToArrayList(array);
    }

    private static ArrayList<String> convertToArrayList(String[] array) {
        ArrayList<String> convertedArray = new ArrayList<String>();

        for (String element : array) {
            convertedArray.add(element);
        }

        return convertedArray;
    }

Для массивов нормального размера справедливы приведенные выше ответы. Если у вас огромный размер массива и вы используете java 8, вы можете сделать это с помощью stream.

  Element[] array = {new Element(1), new Element(2), new Element(3)};
  List<Element> list = Arrays.stream(array).collect(Collectors.toList());