テスト目的でオプションのリストを作成したかったのです。最初に、私はこれをしました：
ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");
次に、コードを次のようにリファクタリングしました。
ArrayList<String> places = new ArrayList<String>(
Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
これを行うより良い方法はありますか？
ArrayListListである必要はありますか?
List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");
または、要素が 1 つしかない場合:
List<String> places = Collections.singletonList("Buenos Aires");
これは、不変であることを意味しplacesます(変更しようとすると、UnsupportedOperationException例外がスローされます)。
具体的な可変リストを作成するには、不変リストからArrayList作成できます。ArrayList
ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
実際には、を初期化するための「最良の」方法ArrayListは、新しいメソッドを作成する必要がないため、作成したメソッドですList。
ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list問題は、そのインスタンスを参照するためにかなりのタイピングが必要なことです。
インスタンス初期化子を使用して匿名の内部クラスを作成するなどの代替手段があります (「二重ブレースの初期化」とも呼ばれます)。
ArrayList<String> list = new ArrayList<String>() {{
add("A");
add("B");
add("C");
}};
ArrayListただし、最終的にはインスタンス初期化子を持つサブクラスになり、そのクラスは1つのオブジェクトを作成するためだけに作成されるため、私はその方法があまり好きではありません.
Project CoinのCollection Literals の提案が受け入れられた場合は、どうでもよかったでしょう(Java 7 で導入される予定でしたが、Java 8 にも含まれる可能性は低いです)。
List<String> list = ["A", "B", "C"];
残念ながら、これはListではなく不変を初期化するため、ここでは役に立ちArrayListません。
List<String> strings = List.of("foo", "bar", "baz");
これにより、不変 Listの が得られるため、変更できません。
これは、事前設定しているほとんどの場合に必要なものです。
List<String> strings = Arrays.asList("foo", "bar", "baz");
これにより、配列に裏打ちされたList*が得られるため、長さを変更できません。
ただし、 を呼び出すことができるList.set(...)ので、まだ変更可能です。
*
実装の詳細: これは、名前が付けられた 内のネストされたプライベート クラスjava.util.Arraysであり、単純な名前は同じですが、 とArrayListは
異なるクラスです。java.util.ArrayList
Arrays.asList静的インポートを使用すると、Java 8をさらに短くすることができます。
import static java.util.Arrays.asList;
...
List<String> strings = asList("foo", "bar", "baz");
最新の IDE *は、これを提案して実行します。
紛らわしいので、List.ofメソッドを単に として静的にインポートすることはお勧めしません。of
*
たとえば、IntelliJ IDEA では、押しAlt+Enterて選択しますStatic import method...
Streamの使用なぜそれはである必要がありListますか？
Java 8 以降Streamでは、より柔軟な を使用できます。
Stream<String> strings = Stream.of("foo", "bar", "baz");
を連結できますStream:
Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
Stream.of("baz", "qux"));
Streamまたは、 aからa に移動できますList。
import static java.util.stream.Collectors.toList;
...
var strings = Stream.of("foo", "bar", "baz").toList(); // Java 16
List<String> strings = Stream.of("foo", "bar", "baz").collect(toList()); // Java 8
ただし、できれば、Streamに収集せずに を使用するだけListです。
java.util.ArrayListを事前入力して後で追加する場合は、ArrayList
List<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");
または Java 8 以前の場合:
List<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");
または使用Stream：
import static java.util.stream.Collectors.toCollection;
List<String> strings = Stream.of("foo", "bar")
.collect(toCollection(ArrayList::new));
strings.add("baz");
ただし、Streamに収集するのではなく、 を直接使用することをお勧めしListます。
*おそらく特に . は必要ありませんArrayList。JEP 269を引用するには:
事前定義された一連の値を使用して可変コレクション インスタンスを初期化するためのいくつかのユース ケースがあります。通常は、これらの定義済みの値を不変コレクションに入れ、コピー コンストラクターを介して可変コレクションを初期化することをお勧めします。
(私のものを強調)
コード内でリストを として宣言したと言いましたが、にない のArrayListメンバーを使用している場合にのみ、それを行う必要があります。ArrayListList
あなたがおそらくしていないこと。
通常は、使用する最も一般的なインターフェイス ( Iterable、Collection、または など) で変数を宣言Listし、特定の実装 ( ArrayList、LinkedListまたは などArrays.asList()) で変数を初期化する必要があります。
そうしないと、コードをその特定のタイプに制限することになり、変更したいときに変更するのが難しくなります。
たとえば、 anArrayListを a に渡す場合void method(...):
// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) {
for (String s : strings) { ... }
}
// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
if (!strings.isEmpty()) { strings.stream()... }
}
// List if you also need random access, .get(index):
void method(List<String> strings) {
strings.get(...)
}
// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
??? // You don't want to limit yourself to just ArrayList
}
InputStreamもう 1 つの例は、通常は aFileInputStreamまたは aである変数を常に宣言することです。これは、いつのBufferedInputStream日か、あなたまたは他の誰かが他の種類の を使用したくなるからですInputStream。
サイズ 1 の単純なリストが必要な場合:
List<String> strings = new ArrayList<String>(Collections.singletonList("A"));
複数のオブジェクトのリストが必要な場合:
List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");
Guavaを使用すると、次のように記述できます。
ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");
Guava には、他にも便利な静的コンストラクターがあります。それらについてはこちらで読むことができます。
コレクション リテラルは Java 8 に組み込まれませんでしたが、Stream API を使用して、かなり長い 1 行でリストを初期化することができます。
List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());
あなたがであることを確認する必要があるList場合ArrayList：
ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));
import com.google.common.collect.ImmutableList;
....
List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ファクトリ メソッドを作成できます。
public static ArrayList<String> createArrayList(String ... elements) {
ArrayList<String> list = new ArrayList<String>();
for (String element : elements) {
list.add(element);
}
return list;
}
....
ArrayList<String> places = createArrayList(
"São Paulo", "Rio de Janeiro", "Brasília");
しかし、最初のリファクタリングよりもはるかに優れているわけではありません。
柔軟性を高めるために、汎用にすることができます。
public static <T> ArrayList<T> createArrayList(T ... elements) {
ArrayList<T> list = new ArrayList<T>();
for (T element : elements) {
list.add(element);
}
return list;
}
これを行う最もコンパクトな方法は次のとおりです。
Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);
トムが言ったように：
List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");
しかし、あなたは ArrayList が欲しいと訴えたので、まずは ArrayList が List のサブクラスであることを知っておく必要があり、次の行を追加するだけで済みます。
ArrayList<String> myPlaces = new ArrayList(places);
ただし、それは「パフォーマンス」に不満を抱かせるかもしれません。
その場合、リストが事前定義されているため、配列として定義されていない理由がわかりません（サイズは初期化時にわかっているため）。そして、それがあなたのためのオプションである場合：
String[] places = {"Buenos Aires", "Córdoba", "La Plata"};
わずかなパフォーマンスの違いを気にしない場合は、配列を ArrayList に非常に簡単にコピーすることもできます。
ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));
わかりましたが、将来的には地名だけでなく、国コードも必要になります。これがまだ定義済みのリストであり、実行時に変更されることはないと仮定すると、enumセットを使用するのに適しています。これは、リストを将来変更する必要がある場合に再コンパイルを必要とします。
enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}
次のようになります。
enum Places {
BUENOS_AIRES("Buenos Aires",123),
CORDOBA("Córdoba",456),
LA_PLATA("La Plata",789);
String name;
int code;
Places(String name, int code) {
this.name=name;
this.code=code;
}
}
values列挙型には、宣言されている順序で列挙型のすべての値を含む配列を返す静的メソッドがあります。次に例を示します。
for (Places p:Places.values()) {
System.out.printf("The place %s has code %d%n",
p.name, p.code);
}
その場合、ArrayList は必要ないと思います。
PS Randyaa は、静的ユーティリティ メソッドCollections.addAllを使用した別の優れた方法を示しました。
はい、配列の助けを借りて、配列リストを1行で初期化できます。
List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");
次のコード行を試してください。
Collections.singletonList(provider)
Javaではできません
ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
指摘されたように、二重中括弧の初期化を行う必要があります。
List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};
ただし、これにより、注釈を追加したり、@SuppressWarnings("serial")煩わしいシリアルUUIDを生成したりする必要が生じる場合があります。また、ほとんどのコードフォーマッターはそれを複数のステートメント/行にアンラップします。
または、
List<String> places = Arrays.asList(new String[] {"x", "y" });
しかし、あなたはしたいかもしれません@SuppressWarnings("unchecked")。
また、javadocによると、これを実行できるはずです。
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
しかし、JDK1.6でコンパイルすることはできません。
Collections.singletonList(messageBody)
1 つの項目のリストが必要な場合は!
コレクションはjava.utilパッケージからのものです。
// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);
// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);
// The most efficient way, which is similar with Arrays.asList(...) in JDK.
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");
宣言： 私は AbacusUtil の開発者です。
それを行う最良の方法：
package main_package;
import java.util.ArrayList;
public class Stackkkk {
public static void main(String[] args) {
ArrayList<Object> list = new ArrayList<Object>();
add(list, "1", "2", "3", "4", "5", "6");
System.out.println("I added " + list.size() + " element in one line");
}
public static void add(ArrayList<Object> list,Object...objects){
for(Object object:objects)
list.add(object);
}
}
必要な数の要素を持つことができる関数を作成し、それを呼び出してそれらを 1 行で追加するだけです。
実際には、1 行で実行できます。
Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})
public static <T> List<T> asList(T... a) {
return new ArrayList<T>(a);
}
これは の実装なArrays.asListので、
ArrayList<String> arr = (ArrayList<String>) Arrays.asList("1", "2");