webdevqa.jp.net

配列からArrayListを作成する

次のように初期化された配列があります。

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

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

ArrayList<Element> arraylist = ???;
3198
Ron Tuffin
new ArrayList<>(Arrays.asList(array))
4212
Tom

与えられた:

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

(古いスレッドだが、Guavaや他のライブラリ、その他の詳細については何も述べていないので、たった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 のための同様のメソッドにも注意してください。

なぜグアバ?

Guava factoryメソッド を使うことでほとんどの場合型を推測できるので、主な魅力は型安全のためのジェネリックによるクラッタを減らすことです。しかし、Java 7が新しいダイヤモンド演算子と共に登場して以来、この議論はより少ない水を保持しています。

しかしそれが唯一の理由ではありません(そしてJava 7はまだどこにでもありません):短縮構文も非常に便利で、上で見たようにメソッド初期化子はもっと表現力豊かなコードを書くことを可能にします。あなたは、1つのGuava呼び出しで、現在のJavaコレクションで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ですが、 NOT Java.util.ArrayListです。これはArrayListをエミュレートしますが、実際には渡された配列を直接参照し、それを "ライトスルー"にします(変更は配列に反映されます)。

それは単にListを拡張することによってAbstractList APIのいくつかのメソッドによる変更を禁止します(したがって、要素を追加または削除することはサポートされていません)が、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+

教育目的のために:Good ol 'Manual Way

// 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);
}
311
haylem

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

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

Java 5以降、Arrays.asList()は可変引数パラメータを取り、明示的に配列を構築する必要はありません。

210
Tim Büthe
new ArrayList<T>(Arrays.asList(myArray));

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

183
Bill the Lizard

別の方法(性能的にはnew ArrayList(Arrays.asList(array))ソリューションと同等ですが)

Collections.addAll(arraylist, array);
83
Peter Tseng

Java 9

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

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

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

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

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

JEP 269 は、 Java Collections API用の便利なファクトリメソッドを提供します。これらの不変の静的ファクトリメソッドは、Java 9以降の ListSet 、および Map インタフェースに組み込まれています。

72
Ali Dehghani

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

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

もう1つのアップデートは、ほぼ2014年になります。Java8でもそれが可能です。

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

これが単なるListである場合、いくつかの文字が保存されます。 

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

あなたが使用する場合:

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

you may create とfill の2つのリスト!容量の拡張が必要になるたびに別の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、またはGuavaを使うのが好きです。しかし、それが合わない場合、またはあなたがそれを感じない場合は、代わりに別の洗練されていない行を書いてください。

31
Nicolas Zozol

Java 9では次のものを使用できます。

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

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

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

しかし、それは常にインターフェースを使用することをお勧めします。

List<Element> arraylist = Arrays.<Element>asList(array);
25
nekperu15739
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
21
Bohdan

あなたはさまざまな方法を使用して変換することができます

  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 を参照してください

17
oxy_js

Java 8のストリームでも可能です。

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

Java 8以降、変換するためのより簡単な方法があります。

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

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

 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");
14
Abojemyeg
  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
Vikrant Kashyap

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

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

for(Element e : array)
    list.add(e);
8
spencer.sm

配列がプリミティブ型の場合、与えられた答えは機能しません。しかし、Java 8以降では、次のものを使用できます。

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

配列をArrayListに簡単に変換することができます。あるリストから別のリストにコンテンツをコピーする目的で、CollectionインタフェースのaddAll()メソッドを使用します。 

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

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

しかし、次の操作はArrayListのListビューだけを返し、実際の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

配列のリスト表現の詳細 link

4
Devendra Lattu

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

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

もう1つのJava 8ソリューション (私は大規模なセットの中で答えを見逃しているかもしれません。もしそうなら、私の謝罪) これは(Listではなく)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);
    }
}

出力は... 
こんにちは 
世界

3
Toothless Seer

次のようにJava 8でそれをすることができます

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

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

だから、ここで私は2つのユースケースのために短い例を挙げます。

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

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

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

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

2
Sumit Das

Cactoos を使用してArrayListを作成できます(私は開発者の一人です)

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

オブジェクトが実際にクラスArrayListであるという保証はありません。その保証が必要な場合は、これを行います。

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

以下のコードを使用

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

型のリストを生成するラムダ式ArrayList<Element>
(1)未チェックのキャストなし
(2)2番目のリストを作成せず(たとえばasList()を使用)

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

0
Kaplan

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());
0
Himanshu Dave

以下に3つの方法を示します。

    Arrays.asList("yellow", "green","blue");

    Collections.singletonList(new String[]{"yellow", "green","blue"});

    Arrays.stream((new String[]{"yellow", "green", "blue"})).collect(Collectors.toList());
0
atul sachan

これはそのための明確な方法です

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