プリミティブlongの配列をLongのリストに変換します
これはちょっとした簡単なヘッドデスクの質問かもしれませんが、私の最初の試みは驚くほど完全に失敗しました。プリミティブなlongの配列を取得してリストに変換したかったので、次のようにしました。
long[] input = someAPI.getSomeLongs();
List<Long> inputAsList = Arrays.asList(input); //Total failure to even compile!
これを行う正しい方法は何ですか？
Apache commons lang ArrayUtils（ JavaDoc 、 Mavenの依存関係 ）を使用して行うと便利です
import org.Apache.commons.lang3.ArrayUtils;
...
long[] input = someAPI.getSomeLongs();
Long[] inputBoxed = ArrayUtils.toObject(input);
List<Long> inputAsList = Arrays.asList(inputBoxed);
また、リバースAPIがあります
long[] backToPrimitive = ArrayUtils.toPrimitive(objectArray);
EDIT：更新され、コメントおよびその他の修正で示唆されているように、リストへの完全な変換を提供します。
Java 8なので、そのためにストリームを使用できます：
long[] arr = {1,2,3,4};
List<Long> list = Arrays.stream(arr).boxed().collect(Collectors.toList());
import Java.util.Arrays;
import org.Apache.commons.lang.ArrayUtils;
List<Long> longs = Arrays.asList(ArrayUtils.toObject(new long[] {1,2,3,4}));
hallidave と jpalecek には正しい考えがあります-配列を反復しますが、ArrayList：が提供する機能を利用しません：sinceこの場合、リストのサイズは既知です。ArrayListを作成するときに指定する必要があります。
List<Long> list = new ArrayList<Long>(input.length);
for (long n : input)
list.add(n);
この方法では、ArrayListがスペース要件を過大評価したために空になる「スロット」が無駄になるため、ArrayListによって破棄されるだけの不要な配列は作成されません。もちろん、リストに要素を追加し続けると、新しいバッキング配列が必要になります。
もう少し冗長ですが、これは動作します：
List<Long> list = new ArrayList<Long>();
for (long value : input) {
list.add(value);
}
この例では、Arrays.asList（）が入力をLongのリストではなくlong []配列のリストとして解釈しているように見えます。確かに少し驚いた。この場合、オートボクシングは期待どおりに機能しません。
別の可能性として、 Guavaライブラリ は、これを Longs.asList() として提供し、他のプリミティブ型の同様のユーティリティクラスを使用します。
import com.google.common.primitives.Longs;
long[] input = someAPI.getSomeLongs();
List<Long> output = Longs.asList(input);
いいえ、プリミティブ型の配列からボックス化された参照型の配列への自動変換はありません。あなただけができる
long[] input = someAPI.getSomeLongs();
List<Long> lst = new ArrayList<Long>();
for(long l : input) lst.add(l);
私はこれらの問題のために小さなライブラリを書いています：
long[] input = someAPI.getSomeLongs();
List<Long> = $(input).toList();
気になる場合は here で確認してください。
Java 8。
long[] input = someAPI.getSomeLongs();
LongStream.of(input).boxed().collect(Collectors.toList()));
質問は、配列をリストに変換する方法について尋ねました。これまでのほとんどの回答では、アレイと同じコンテンツを使用したnewリストを作成する方法、またはサードパーティライブラリを参照する方法を示しました。ただし、この種の変換には単純な組み込みオプションがあります。それらのいくつかは、他の回答で既にスケッチされています（例： this one ）。しかし、ここで実装の特定の自由度を指摘し、詳細に説明し、潜在的な利点、欠点、および警告を示したいと思います。
少なくとも2つの重要な違いがあります。
- 結果のリストが配列上のviewであるか、またはnewリストであるか
- 結果のリストをmodifiableにするかどうか
オプションはここですぐに要約され、完全なサンプルプログラムがこの回答の下部に表示されます。
新しいリストの作成とアレイ上のviewの作成
結果がnewリストの場合、他の回答からのアプローチの1つを使用できます。
List<Long> list = Arrays.stream(array).boxed().collect(Collectors.toList());
ただし、これを行うことの欠点を考慮する必要があります。1000000long値を持つ配列は、約8メガバイトのメモリを占有します。新しいリストはalso約8メガバイトを占有します。そしてもちろん、このリストを作成する際には、配列全体を走査する必要があります。多くの場合、新しいリストを作成する必要はありません。代わりに、配列にviewを作成するだけで十分です。
// This occupies ca. 8 MB
long array[] = { /* 1 million elements */ }
// Properly implemented, this list will only occupy a few bytes,
// and the array does NOT have to be traversed, meaning that this
// operation has nearly ZERO memory- and processing overhead:
List<Long> list = asList(array);
（toListメソッドの実装については、下部の例を参照してください）
配列にviewがあることの意味は、配列の変更がリストに表示されることです：
long array[] = { 12, 34, 56, 78 };
List<Long> list = asList(array);
System.out.println(list.get(1)); // This will print 34
// Modify the array contents:
array[1] = 12345;
System.out.println(list.get(1)); // This will now print 12345!
幸いなことに、ビューからコピー（つまり、配列の変更の影響を受けないnewリスト）を作成するのは簡単です。
List<Long> copy = new ArrayList<Long>(asList(array));
さて、これは真のコピーであり、上に示したストリームベースのソリューションで達成されるものと同等です。
modifiableビューまたはunmodifiableビューの作成
多くの場合、リストがread-onlyであれば十分です。結果のリストの内容は変更されないことが多く、リストを読み取るだけのダウンストリーム処理にのみ渡されます。
リストの変更を許可すると、いくつかの疑問が生じます。
long array[] = { 12, 34, 56, 78 };
List<Long> list = asList(array);
list.set(2, 34567); // Should this be possible?
System.out.println(array[2]); // Should this print 34567?
list.set(3, null); // What should happen here?
list.add(99999); // Should this be possible?
modifiableである配列にリストビューを作成することができます。これは、特定のインデックスに新しい値を設定するなど、リストの変更が配列に表示されることを意味します。
ただし、構造的に変更可能なリストビューを作成することはできません。これは、リストのsizeに影響する操作を実行できないことを意味します。これは、基礎となるarrayのサイズを変更できないためです。
以下は [〜＃〜] mcve [〜＃〜] で、さまざまな実装オプションと、結果リストの使用方法を示しています。
import Java.util.AbstractList;
import Java.util.ArrayList;
import Java.util.Arrays;
import Java.util.List;
import Java.util.Objects;
public class PrimitiveArraysAsLists
{
public static void main(String[] args)
{
long array[] = { 12, 34, 56, 78 };
// Create VIEWS on the given array
List<Long> list = asList(array);
List<Long> unmodifiableList = asUnmodifiableList(array);
// If a NEW list is desired (and not a VIEW on the array), this
// can be created as well:
List<Long> copy = new ArrayList<Long>(asList(array));
System.out.println("array : " + Arrays.toString(array));
System.out.println("list : " + list);
System.out.println("unmodifiableList: " + unmodifiableList);
System.out.println("copy : " + copy);
// Modify a value in the array. The changes will be visible
// in the list and the unmodifiable list, but not in
// the copy.
System.out.println("Changing value at index 1 of the array...");
array[1] = 34567;
System.out.println("array : " + Arrays.toString(array));
System.out.println("list : " + list);
System.out.println("unmodifiableList: " + unmodifiableList);
System.out.println("copy : " + copy);
// Modify a value of the list. The changes will be visible
// in the array and the unmodifiable list, but not in
// the copy.
System.out.println("Changing value at index 2 of the list...");
list.set(2, 56789L);
System.out.println("array : " + Arrays.toString(array));
System.out.println("list : " + list);
System.out.println("unmodifiableList: " + unmodifiableList);
System.out.println("copy : " + copy);
// Certain operations are not supported:
try
{
// Throws an UnsupportedOperationException: This list is
// unmodifiable, because the "set" method is not implemented
unmodifiableList.set(2, 23456L);
}
catch (UnsupportedOperationException e)
{
System.out.println("Expected: " + e);
}
try
{
// Throws an UnsupportedOperationException: The size of the
// backing array cannot be changed
list.add(90L);
}
catch (UnsupportedOperationException e)
{
System.out.println("Expected: " + e);
}
try
{
// Throws a NullPointerException: The value 'null' cannot be
// converted to a primitive 'long' value for the underlying array
list.set(2, null);
}
catch (NullPointerException e)
{
System.out.println("Expected: " + e);
}
}
/**
* Returns an unmodifiable view on the given array, as a list.
* Changes in the given array will be visible in the returned
* list.
*
* @param array The array
* @return The list view
*/
private static List<Long> asUnmodifiableList(long array[])
{
Objects.requireNonNull(array);
return new AbstractList<Long>()
{
@Override
public Long get(int index)
{
return array[index];
}
@Override
public int size()
{
return array.length;
}
};
}
/**
* Returns a view on the given array, as a list. Changes in the given
* array will be visible in the returned list, and vice versa. The
* list does not allow for <i>structural modifications</i>, meaning
* that it is not possible to change the size of the list.
*
* @param array The array
* @return The list view
*/
private static List<Long> asList(long array[])
{
Objects.requireNonNull(array);
return new AbstractList<Long>()
{
@Override
public Long get(int index)
{
return array[index];
}
@Override
public Long set(int index, Long element)
{
long old = array[index];
array[index] = element;
return old;
}
@Override
public int size()
{
return array.length;
}
};
}
}
例の出力は次のとおりです。
array : [12, 34, 56, 78]
list : [12, 34, 56, 78]
unmodifiableList: [12, 34, 56, 78]
copy : [12, 34, 56, 78]
Changing value at index 1 of the array...
array : [12, 34567, 56, 78]
list : [12, 34567, 56, 78]
unmodifiableList: [12, 34567, 56, 78]
copy : [12, 34, 56, 78]
Changing value at index 2 of the list...
array : [12, 34567, 56789, 78]
list : [12, 34567, 56789, 78]
unmodifiableList: [12, 34567, 56789, 78]
copy : [12, 34, 56, 78]
Expected: Java.lang.UnsupportedOperationException
Expected: Java.lang.UnsupportedOperationException
Expected: Java.lang.NullPointerException
別の way with Java 8。
final long[] a = new long[]{1L, 2L};
final List<Long> l = Arrays.stream(a).boxed().collect(Collectors.toList());
PavelとTomの回答を組み合わせると、これが得られます
@SuppressWarnings("unchecked")
public static <T> List<T> asList(final Object array) {
if (!array.getClass().isArray())
throw new IllegalArgumentException("Not an array");
return new AbstractList<T>() {
@Override
public T get(int index) {
return (T) Array.get(array, index);
}
@Override
public int size() {
return Array.getLength(array);
}
};
}
私はこの質問が十分に古いことを知っていますが、...独自の変換方法を書くこともできます：
@SuppressWarnings("unchecked")
public static <T> List<T> toList(Object... items) {
List<T> list = new ArrayList<T>();
if (items.length == 1 && items[0].getClass().isArray()) {
int length = Array.getLength(items[0]);
for (int i = 0; i < length; i++) {
Object element = Array.get(items[0], i);
T item = (T)element;
list.add(item);
}
} else {
for (Object i : items) {
T item = (T)i;
list.add(item);
}
}
return list;
}
静的インポートを使用してインクルードした後、考えられる使用法は次のとおりです。
long[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<Long> list = toList(array);
または
List<Long> list = toList(1l, 2l, 3l, 4l, 5l, 6l, 7l, 8l, 9l);
Arrays.asListと同様のセマンティクスが必要な場合は、Listの顧客実装を記述する（または他の誰かの使用する）必要があります（おそらくAbstractListを使用します。ほとんど同じ実装が必要です。 Arrays.asListとして、ボックスとボックス解除の値のみ。
transmorph を使用できます：
Transmorph transmorph = new Transmorph(new DefaultConverters());
List<Long> = transmorph.convert(new long[] {1,2,3,4}, new TypeReference<List<Long>>() {});
たとえば、sourceがintの配列の場合にも機能します。
新しいリストを作成してすべての値を追加することは可能ですが（forループまたはストリームを介して）、私は非常に大きな配列に取り組んでおり、パフォーマンスが低下します。したがって、使いやすいプリミティブ配列ラッパークラスを独自に作成しました。
例：
long[] arr = new long[] {1,2,3};
PrimativeList<Long> list = PrimativeList.create(arr); // detects long[] and returns PrimativeList<Long>
System.out.println(list.get(1)); // prints: 2
list.set(2, 15);
System.out.println(arr[2]); // prints: 15
注：まだ完全にはテストしていませんので、バグや問題が見つかった場合はお知らせください。
LongStreamを使用できます
List<Long> longs = LongStream.of(new long[]{1L, 2L, 3L}).boxed()
.collect(Collectors.toList());