配列からArrayListを作成する


3596

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

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

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

ArrayList<Element> arraylist = ???;

49
Java9の場合-> List <String> list = List.of(“ Hello”、“ World”、“ from”、“ Java”);
MarekM 2017

18
@MarekMこれはを返さないため、間違っていArrayListます。ポスターは特にそれを求めました。
ドリアングレイ

4
ベストプラクティスであるため、彼はリストインターフェイスを使用して採掘しなかったと思います。しかし、ここで必要なのは-新しいArrayList <>(List.of(“ Hello”、“ World”、“ from”、“ Java”));
MarekM 2017年

10
重要なのは、インターフェイスを使用することではなく、ソリューションでは、返されたリストは変更できないということです。それはもっと問題かもしれません、そして彼がArrayListを求めた理由
ドリアン・グレイ

回答:


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

361
うん。また、リストが必要な(最も一般的な)ケースでは、new ArrayList呼び出しも不要です。
Calum

143
@Luron-使用するだけList<ClassName> list = Arrays.asList(array)
プール

248
@Calumと@Pool-以下のAlex Millerの回答Arrays.asList(array)で説明されているように、新しいArrayListオブジェクトに渡さずに使用すると、リストのサイズが固定されます。を使用する最も一般的な理由の1つは、ArrayListそのサイズを動的に変更できることであり、あなたの提案はこれを防ぐでしょう。
コードジョッキー

130
Arrays.asList()は恐ろしい関数であり、戻り値をそのまま使用することはできません。リストテンプレートが壊れるので、冗長に思われる場合でも、必ずここに示す形式で使用してください。いい答えです。
Adam

83
@Adam java.util.Listのjavadocを調べてください。追加のコントラクトにより、UnsupportedOperationExceptionをスローできます。docs.oracle.com/javase/7/docs/api/java/util/… 確かに、オブジェクト指向の観点からすると、コレクションを使用するために具体的な実装を知っておく必要があることはよくありません-これフレームワークをシンプルに保つための実用的なデザインの選択でした。
lbalazscs 2013

918

与えられた:

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()、元の配列によって支えられています。元の配列を変更すると、リストも変更されます。これは意外かもしれません。

6
両方の操作の時間の複雑さはどれくらいですか?つまり、明示的なarraylist構造を使用する場合と使用しない場合です。
のろわ

35
Arrays.asList()は、既存の配列をラップしてArrayListを作成するだけなので、O(1)になります。
Alex Miller

27
新しいArrayList()でラップすると、固定サイズのリストのすべての要素が反復され、新しいArrayListに追加されます。O(n)も同様です。
Alex Miller

8
asList()によって返されるListの実装は、UnsupportedOperationExceptionを説明するListのいくつかのメソッド(add()、remove()、clear()など)を実装していません。間違いなく警告...
sethro 2012年

8
質問が「ArrayListクラスのオブジェクト」を要求するとき、私はそれが参照するクラスがであると想定することは合理的だと思いますjava.util.ArrayList。Arrays.asListは実際には、他のクラスjava.util.Arrays.ArrayListではないを返しますinstanceof。したがって、3つ目の注意点は、上記を必要とするコンテキストで使用しようとしても機能しないことです。
Dave L.

352

(古いスレッドですが、グアバやその他のライブラリやその他の詳細については誰も言及していないため、わずか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);
}

27
+1しかし、要素を変更できるという点で、Listによって返されるArrays.asListは変更可能であることに注意してくださいset。サイズを変更することはできません。グアバのない不変のリストについては、あなたが言及するかもしれませんCollections.unmodifiableList
Paul Bellora 2013年

1
@haylemあなたのセクションfor Educational Purposes:The Good ol 'Manual Wayで、あなたのarrayToListfor Java 1.5+は正しくありません。Stringジェネリックパラメータータイプを使用する代わりに、のリストをインスタンス化し、指定された配列から文字列を取得しようとしていますT。それ以外は、良い答えであり、手動の方法を含む唯一の方法である+1です。
afsantos 2013年

ラップされた配列を後で変更することによって変更できるため、セクションの名前を「変更できない場合/不変リストの場合」から「変更不可能なリストの場合」に変更します。それはまだO(1)ですが、不変性のために、たとえばによってコピーを作成する必要がありますCollections.unmodifiableList(new ArrayList<>(Arrays.asList(array)))
maaartinus

232

この質問はかなり古いので、誰もまだ最も単純な形式を提案していないことに驚きます。

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

Java 5以降Arrays.asList()は、varargsパラメーターを使用するため、配列を明示的に作成する必要はありません。


7
特に、List<String> a = Arrays.asList("first","second","third")
18446744073709551615

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

それmyArrayがと同じタイプであることを確認してくださいT。たとえばのList<Integer>配列からを作成しようとすると、コンパイラエラーが発生しますint


103

別の方法(基本的にnew ArrayList(Arrays.asList(array))ソリューションのパフォーマンスと同等ですが:

Collections.addAll(arraylist, array);

96

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のいくつかの便利なファクトリメソッドを提供します。これらの不変の静的なファクトリメソッドを内蔵しているListSetと、Map以降のJava 9とのインターフェイス。


List.of()は、元の質問で要求されたとおり、java.util.ArrayListのインスタンスを返しません。したがって、2番目のオプションのみが有効な答えです。
tquadrat

84

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

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

8
これは、元の入力配列によって裏付けられます。そのため、(おそらく)新しいArrayListにラップする必要があります。
トカゲに請求する

16
このソリューションには注意してください。見てみると、配列は真のjava.util.ArrayListを返しません。必要なメソッドを実装する内部クラスを返しますが、リストのメンバーを変更することはできません。それは単に配列のラッパーです。
Mikezx6r 2008年

1
List <Element>アイテムをArrayList <Element>にキャストできます
monksy

12
@ Mikezx6r:少し修正:固定サイズのリストです。あなたは、リスト(の要素を変更することができるset方法を)、リスト(ないのサイズ変更できないaddremoveの要素を)!
user85421 2009

1
はい、それはあなたがリストで何をしたいかに依存することに注意してください。OPが単に要素を反復処理する場合は、配列を変換する必要がないことは注目に値します。
PaulMurrayCbr 2013

69

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

8
おそらく実装に依存しないことが最善ですが、Collectors.toList()実際にはを返しますArrayList
bcsb1001 2014

Stream.of(...);の誤った使用 これにより、1つの要素のストリームが作成されます。代わりにArrays.streamを使用してください
Patrick Parker

私はそうは思いません、2つのオプションは有効ですが、Arrays.streamは、 'start'、 'end'引数を指定したオーバーロードメソッドを使用して固定サイズで作成できるため、わずかに 'より良い'です。次も参照してください:stackoverflow.com/a/27888447/2619091
whyem '30

41

使用する場合:

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

私が使用するのが大好きCollectionsArraysまたはグアバ。しかし、合わない場合、または感じられない場合は、代わりに別のエレガントな行を作成してください。


1
答えの最後のループと、new ArrayList<T>(Arrays.asList(myArray));使用を思いとどまらせる部分との根本的な違いはわかりません。どちらもまったく同じであり、複雑さも同じです。
glglgl 2015

コレクションは、配列の先頭にポインタを作成します。私のループは多くのポインターを作成します:各配列メンバーに1つ。したがって、元の配列が変更された場合でも、私のpoinersは以前の値に向けられています。
Nicolas Zozol、2015

1
new ArrayList<T>(Arrays.asList(myArray));同じ、それのコピーがないasListArrayList...
glglgl

37

ではJava 9、あなたが使用することができます。

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

明示的に要求されたため、これはArrayListではないことに注意してください。
ドリアングレイ

33

質問によると、Java 1.7を使用した答えは次のとおりです:

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

ただし、常にインターフェースを使用する方がよいでしょう。

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

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


21

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

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


18

Java 8のストリームを使用して行うこともできます。

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

3
のとしてのJava 8Collectors.toList()返されますArrayList。ただし、これはjavaの将来のバージョンでは異なる可能性があります。特定のタイプのコレクションCollectors.toCollection()が必要な場合は、代わりにを使用して、作成するコレクションの正確なタイプを指定できます。
Raja Anbazhagan

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

10

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

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

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

10

配列がプリミティブ型の場合、指定された回答は機能しません。しかし、Java 8以降では以下を使用できます。

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

このソリューションもchar配列では機能しないようです。
PixelMaster

8

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

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

1
そのキャストは非常に危険に見えるため、反対票を投じました。何も指定が返されるリストのタイプは、実際のArrayListは、javadocの状態とされていること:「タイプの保証はありません、リストの可変性、直列可能、またはスレッドの安全性は、返された」
ドリアングレイ

1
あなたが明示的にArrayListのを作成したい場合は、これを試してください:ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
ドリアングレイ

8

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

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

これは、受け入れられた9年前の回答よりも効率的ではありません。
AjahnCharles 2017

2
ArrayListsコンストラクタの1つが? extends Collection<T>引数を受け取り、addAll冗長な呼び出しを行います。
Tamoghna Chowdhury 2017

7

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

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

配列リンクのリスト表現の詳細。


7

これを行う最も簡単な方法は、次のコードを追加することです。試してテストしました。

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

7

別の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


7

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

5

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

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

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

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

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

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


List <Element> elementList = Arrays.asList(array)は、元の配列のラッパーを作成し、元の配列をListとして使用できるようにします。したがって、ラッパーオブジェクトが作成され、元の配列から何もコピーされません。したがって、要素の追加や削除などの操作は許可されません。
Priyanka

3
あなたの「不変コレクションは」本当に不変でないことに注意してください- Listによって返さはArrays.asList元の配列を超えるだけのラッパーであり、個々の項目を介してアクセスして変更することを可能にするgetset。「不変」ではなく「要素を追加または削除しない」ことを意味することを明確にする必要があります。つまり、まったく変更しないことを意味します。
Tamoghna Chowdhury 2017

5

与えられたオブジェクト配列:

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


4

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

3

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

new ArrayList<T>(Arrays.asList(myArray));
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.