私は次のように初期化された配列を持っています：

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

この配列をArrayListクラスのオブジェクトに変換したいと思います。

ArrayList<Element> arraylist = ???;

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セントです）}

可能であれば、グアバを使用する

グアバの方法を指摘することは価値があります。これはこれらの悪意を大幅に簡素化します。

使用法

不変リストの場合

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がまだどこにでもあるわけではありません）。略記構文も非常に便利であり、メソッドの初期化子は、上記のように、より表現力豊かなコードを記述できます。現在のJavaコレクションでは、1回のGuavaコールで2が必要です。

できない場合...

不変リストの場合

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

Java 9

ではJavaの9は、使用することができますList.of作成するために、静的なファクトリメソッドをListリテラルを。次のようなもの：

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

これは、3つの要素を含む不変のリストを返します。変更可能なリストが必要な場合は、そのリストをArrayListコンストラクターに渡します。

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

JEP 269：コレクションのコンビニエンスファクトリメソッド

JEP 269は、Javaコレクション APIのいくつかの便利なファクトリメソッドを提供します。これらの不変の静的なファクトリメソッドを内蔵しているList、Setと、Map以降のJava 9とのインターフェイス。

おそらく、ArrayListではなくListだけが必要です。その場合、あなたはただ行うことができます：

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

2014年にほぼ終了するもう1つの更新は、Java 8でも実行できます。

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

これが単なる List

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

使用する場合：

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

あなたはあり作成し、記入二つのリストを！Object[]容量を拡張する必要があるたびに別のアレイが作成されるため、大きなリストを2回埋めることは、まさに望まないことです。

幸い、JDKの実装は高速で、Arrays.asList(a[])非常によく行われています。Object []データが配列を直接指すArrays.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を参照してください。

すべてが言ったように、これはそうするでしょう

 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（）arraylistによってサポートされる新しい空の監視可能なリストを作成します。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()); 

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

別の簡単な方法は、for-eachループを使用して、配列のすべての要素を新しいArrayListに追加することです。

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

あなたは次のようにJava 8でそれを行うことができます

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

配列は簡単にに変換できますArrayList。addAll()あるリストから別のリストにコンテンツをコピーするために、コレクションインターフェイスのメソッドを使用します。

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

この質問には完全に書かれた回答がたくさんありますが、私は私の入力を追加します。

あなたが持っていると言う 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));

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

出力は...
Hello
world

次のコードを使用して、要素配列を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]);
}

すでに誰もがあなたの問題に対して十分な答えを提供しています。次に、すべての提案から、要件に合うものを決定する必要があります。知っておくべきコレクションには2つのタイプがあります。1つは変更されていないコレクションで、もう1つは後でオブジェクトを変更できるコレクションです。

そこで、ここでは2つの使用例の短い例を示します。

• 不変コレクションの作成::作成後にコレクションオブジェクトを変更したくない場合

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

３

Java 8のArraysクラスは、プリミティブ配列とオブジェクト配列の両方を受け入れるオーバーロードされたバージョンを持つ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());

以下のコードはこれを行うための良い方法のようです。

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