本文へスキップ

本ページはプロモーションが含まれています

Java入門

Javaコレクション入門|List・Set・Mapの違いと使い分け

CATEGORY
DRAWN BY
TOM
DATE
REV.
READ
約20分
SHEETS
9枚
コレクション(List・Set・Mapの使い分け)

トム

SESで約8年、環境を変えられないもどかしさの中にいました。32歳で自社開発企業に転職し、今はClaude Codeと自動化で、仕事も時間も組み直している途中です。
・Javaバックエンドエンジニア(Java歴12年以上)
・資格:基本情報技術者/応用情報技術者/Java Silver/Python3エンジニア認定基礎
詳細なプロフィール

𝕏

new ArrayList<>() と書きかけた手が、ふと止まる。Set のほうがいいのか、HashMap と TreeMap は何が違うのか。

Javaのコレクションは、並び順・重複・取り出し方の3つの質問に答えれば、List・Set・Map・Queue のどれかに絞れます。実装クラスは、その先で性能とnullの扱いを見て決めます。

この記事は、コレクション全体の地図です。階層図と実装クラスの選び方表、配列との違い、変更できないコレクションを順に見ます。 Java 21の SequencedCollection と、つまずきやすい6つの間違いも実行結果つきで載せました(コードはすべてJava 23(OpenJDK 23.0.1)で動かして確認しています)。

この記事でわかること

  • Collection・List・Set・Queue・Deque・Map がどうつながっているか
  • 3つの質問で、ArrayList・HashSet・HashMap などを選ぶ手順
  • 配列とコレクションの違いと、行き来するときの落とし穴
  • List.of・Collections.unmodifiableList・List.copyOf の違い
  • Java 21で入った getFirst()・getLast()・reversed() の使いどころ

この記事の役割
学習の道順を知りたいときはJava入門ロードマップが担当です。こちらは「道順」ではなく「コレクションの地図」で、個別の使い方は List・Map・重複チェック の各記事に任せています。

PARTS LIST /目次

Javaのコレクションとは?6つの入れ物の地図

コレクションとは、複数のオブジェクトをまとめて扱うための入れ物です。Javaには、その入れ物の作りと操作を揃えた「コレクションフレームワーク」があり、中身の実装を知らなくても同じ書き方で扱えるようになっています。

公式のコレクションフレームワーク概要は、コレクションを「オブジェクトのグループを表すオブジェクト」と定義しています。実装の詳細に依存せず操作できる、統一的な仕組みという説明です。ArrayList がその代表例です。

主役になるインターフェースは6つです。まず全体の形を図で見ておきます。

Collectionの下に並ぶ4つの入れ物

Collection の下に、List・Set・Queue・Deque が並びます。Java 21からは、順序を持つ入れ物の共通の親として SequencedCollection が加わりました。

flowchart TD
    I["Iterable"] --> C["Collection"]
    C --> SC["Sequenced<br>Collection<br>(Java 21)"]
    C --> S["Set"]
    C --> Q["Queue"]
    SC --> L["List"]
    SC --> D["Deque"]
    Q --> D
    S --> SS["Sequenced<br>Set<br>(Java 21)"]
    SC --> SS
    SS --> SO["SortedSet"]
    SO --> NS["NavigableSet"]

上の図は、各インターフェースの getInterfaces() を実際に出力して確かめた継承関係です(図のように、Deque は Queue と SequencedCollection の両方を、SequencedSet は SequencedCollection と Set の両方を継承します)。

List extends SequencedCollection
Set extends Collection
Queue extends Collection
Deque extends Queue, SequencedCollection
SequencedCollection extends Collection
SequencedSet extends SequencedCollection, Set
SortedSet extends Set, SequencedSet
NavigableSet extends SortedSet

入れ物ごとの性格は、次の4行で足ります。

  • List:順番に並び、同じ値を何個でも入れられる。番号(インデックス)で取り出せる
  • Set:同じ値を2個入れられない。「あるかないか」を調べるのが得意
  • Queue:出口が決まっている行列。先頭から取り出す
  • Deque:両端から出し入れできる行列。スタックとしても使える

Mapは別の系統にいる

Map は Collection を継承しません。公式の概要でも、Map を土台にしたインターフェースは「真のコレクションではない」と書かれています。キーと値の組を持つため、要素1個を出し入れする Collection の約束と合わないからです。

System.out.println(Collection.class.isAssignableFrom(Map.class));
false

Map 側も、SequencedMap(Java 21)→ SortedMap → NavigableMap と段階的に広がります。ただし keySet()・values()・entrySet() で中身を Set や Collection として取り出せるので、for 文で回すときは Collection と同じ感覚で書けます。

Map ← SequencedMap ← SortedMap ← NavigableMap

List・Set・Mapの違いと使い分けは3つの質問で決まる

使い分けの判断は、クラス名の暗記ではなく、先に3つの質問に答える形で進めると迷いません。質問の答えが、List・Set・Map・Queue のどれを選ぶかを決め、そのあとで実装クラスを選びます。

3つの質問で入れ物を絞る

3つの質問は、次のとおりです。

  1. キーと値のペアで持ちたいか(名前から値を引きたいか)
  2. 同じ値を複数入れたいか
  3. どう取り出したいか(番号・両端・小さい順・存在確認)
flowchart TD
    A{"キーと値の<br>ペアで持つ?"}
    A -->|"はい"| M["Map系<br>HashMap<br>LinkedHashMap<br>TreeMap"]
    A -->|"いいえ"| B{"同じ値を<br>複数入れる?"}
    B -->|"はい"| LD["List・Deque系<br>ArrayList<br>ArrayDeque<br>PriorityQueue"]
    B -->|"いいえ"| SE["Set系<br>HashSet<br>LinkedHashSet<br>TreeSet"]

PriorityQueue を「重複を許す側」に置いたのは、同じ値を複数入れられるからです。取り出し順が「小さい順」になるだけで、重複は排除されません。

実装クラスの選び方表

入れ物が決まったら、実装クラスを選びます。公式の概要は、汎用実装を「中身のデータ構造」で整理しています。ハッシュ表なら HashSet・HashMap、可変長配列なら ArrayList・ArrayDeque、平衡木なら TreeSet・TreeMap、連結リストなら LinkedList、ハッシュ表と連結リストの合わせ技なら LinkedHashSet・LinkedHashMap です。

クラス中身並び順重複null向いている場面
ArrayList可変長配列入れた順可可番号で取り出す・順に回す(迷ったらこれ)
LinkedList双方向連結リスト入れた順可可List と Deque の両方が欲しい特殊な場面
HashSetハッシュ表保証なし不可1個だけ可重複排除・存在確認
LinkedHashSetハッシュ表+連結リスト入れた順不可可重複排除しつつ順序を残す
TreeSet平衡木比較順不可不可(自然順序)ソート済みで持つ・範囲を切り出す
ArrayDeque可変長配列両端で出し入れ可不可スタック・キュー
PriorityQueue優先度ヒープ取り出しだけ小さい順可不可最小の要素から処理する
HashMapハッシュ表保証なしキーは不可キー・値とも可名前から値を引く(標準)
LinkedHashMapハッシュ表+連結リスト入れた順キーは不可キー・値とも可入れた順に取り出すMap
TreeMap平衡木キーの比較順キーは不可キーは不可キー順に並べる・範囲検索

並び順・重複・nullの列は、Javadocの記述と、実際に null を入れて確かめた結果に合わせています。TreeSet と TreeMap のキーは、自然順序(Comparable)を使うかぎり null を入れると NullPointerException になりました。

TreeSet.add(null): NullPointerException
ArrayDeque.add(null): NullPointerException
PriorityQueue.add(null): NullPointerException
HashMap.put(null,1): OK
TreeMap.put(null,1): NullPointerException
TreeMap.put("k",null): OK

計算量は、Javadocが約束している範囲だけを挙げます。

  • ArrayList:get・set は定数時間、add は償却定数時間。そのほかの操作は線形時間
  • HashSet・HashMap:add・contains・get・put は定数時間(ハッシュ関数が要素を適切に散らす前提)
  • TreeSet・TreeMap:add・remove・contains(get・put)は log(n) 時間が保証されている
  • PriorityQueue:offer・poll は log(n) 時間、remove(Object)・contains は線形時間、peek は定数時間
  • ArrayDeque:スタックとして使うと Stack より、キューとして使うと LinkedList より速い見込み

LinkedList を選ぶ理由が薄いのは、この最後の行が根拠です。キューやスタックの用途なら ArrayDeque のほうが速い見込みで、List として使うなら ArrayList の定数倍のコストが低いと、ArrayList のJavadocが書いています。迷ったら ArrayList・HashMap・HashSet から始めて、並び順や性能の理由が出てから変える、で足ります。

Stack と Vector は新しく選ばない
Stack のJavadocは、スタック操作には Deque とその実装を優先して使うよう書いています。例は Deque<Integer> stack = new ArrayDeque<Integer>(); です。

並び順の違いを動かして確かめる

「並び順が保証されない」は、動かさないと実感しにくい性質です。同じ入力を HashSet・LinkedHashSet・TreeSet に入れて、出力を比べます。

String[] in = {"banana", "apple", "cherry", "apple", "date"};

Set<String> hs  = new HashSet<>(Arrays.asList(in));
Set<String> lhs = new LinkedHashSet<>(Arrays.asList(in));
Set<String> ts  = new TreeSet<>(Arrays.asList(in));
入力        : [banana, apple, cherry, apple, date]
HashSet     : [banana, date, apple, cherry]
LinkedHashSet: [banana, apple, cherry, date]
TreeSet     : [apple, banana, cherry, date]
HashMap     : {banana=1, date=5, apple=4, cherry=3}
LinkedHashMap: {banana=1, apple=4, cherry=3, date=5}
TreeMap     : {apple=4, banana=1, cherry=3, date=5}

apple は入力に2回ありますが、Set には1個しか残りません。Map では、同じキーに2回 put すると値が上書きされ、apple の値は 4 になっています。

HashSet の順序は、今回のJavaではたまたまこう並んだだけです。Javadocは「順序を保証せず、時間が経っても同じ順序のままとは限らない」と書いています。順序に頼るコードを書いてはいけません。

Queue 系は、取り出し方の違いが出ます。ArrayDeque はスタックにもキューにもなり、PriorityQueue は取り出すと小さい順に出てきます。

pop         : 3 2 1
poll        : 1 2 3
空の poll   : null
PQ toString : [1, 2, 4, 5, 3]
PQ poll順   : 1 2 3 4 5

PriorityQueue を println すると [1, 2, 4, 5, 3] と、ソートされていない順で出ます。内部はヒープで、iterator() もどんな順序での走査も保証されないとJavadocに書かれています。小さい順に使えるのは poll() で取り出すときだけです。

配列とコレクションの違いは何か

配列(int[] など)もコレクションも「複数の値をまとめる」点は同じです。違いは、長さを変えられるか、どんな型を持てるか、Collection の操作が使えるかにあります。配列そのものの使い方はJava配列の基本の記事が詳しいので、ここでは選び方の観点だけに絞ります。

配列とArrayListの比較

配列は長さを最初に決めて、後から変えられません。ArrayList は要素を足すと自動で伸びます。

int[] arr = new int[3];
arr[0] = 10;
arr[3] = 40;   // 範囲外

List<Integer> list = new ArrayList<>();
for (int i = 0; i < 5; i++) list.add(i * 10);
配列: Index 3 out of bounds for length 3
ArrayList: [0, 10, 20, 30, 40] size=5
観点配列コレクション(ArrayListなど)
長さ作るときに固定要素の追加で伸びる
要素の型基本型(int)も参照型も持てる参照型だけ(int は Integer に包まれる)
操作length と添字add・remove・contains・stream() など
順序・重複以外の性質なしSet や Map など目的別に選べる
向いている場面長さが決まっている固定データ・main の引数件数が変わるデータ全般

List<int> はコンパイルエラーです。型パラメータに基本型は書けず、List<Integer> のようにラッパークラスを使います。型引数の仕組みはJavaジェネリクス入門で扱っています。

配列とListを行き来するときの落とし穴

配列から List を作る Arrays.asList は、見た目は ArrayList のようで、動きが違います。Javadocは「指定された配列に裏打ちされた、固定サイズのリスト」と説明しています。

String[] src = {"x", "y", "z"};
List<String> view = Arrays.asList(src);
view.set(0, "X");
System.out.println(Arrays.toString(src));
src[1] = "Y";
System.out.println(view);
view.add("w");
set 後の配列: [X, y, z]
配列を変えた後の List: [X, Y, z]
Arrays.asList の add: UnsupportedOperationException

set は通り、元の配列にも書き込まれます。add は固定サイズなので UnsupportedOperationException になります。要素を足したいときは、new ArrayList<>(Arrays.asList(src)) のようにコピーしてから使います。

もう一つ、基本型の配列は Arrays.asList に渡すと、要素ではなく「配列1個」を要素にした List になります。

Integer[] -> List の size: 3
int[]     -> List の size: 1

int[] から List<Integer> を作りたいときは、Arrays.stream(prim).boxed().toList() で作ります(実行結果は [1, 2, 3])。逆向きは list.toArray(new String[0]) です。

Java Silverでコレクションはどこまで出るか

Java Silverの試験を考えて「コレクションはどこまで必要か」を調べる人も多いでしょう。Java SE 17 Programmer I(1Z0-825-JPN)のOracle公式チェックリストでは、配列(一次元・二次元)とあわせて ArrayList の使用が出題範囲に入っています。 ここで挙げたクラス全部を暗記する試験ではありません。土台は、配列と ArrayList を確実に扱えることです。

私自身はJava Silverに1回目は55%で不合格、問題集を3周やり直した2回目で82%の得点で合格しました。勉強の進め方はJava Silver勉強時間|未経験3ヶ月の合格法にまとめています。Silverの範囲を超えても、HashMap や HashSet は実務のコードで広く使われるので、この記事の選び方表は試験のあとにも使えます。

変更できないコレクション|List.of・unmodifiableList・copyOfの違い

「変更できないリストを作る」方法は3つあり、見た目は似ていますが性質が違います。List.of は新しい不変リストを作り、Collections.unmodifiableList は元のリストの読み取り専用ビューを返し、List.copyOf は不変のコピーを返します。

3つを同じ条件で動かして比べる

元のリスト [a, b] から3つを作り、そのあと元のリストに c を足してみます。

List<String> base = new ArrayList<>(List.of("a", "b"));

List<String> view    = Collections.unmodifiableList(base);
List<String> copy    = List.copyOf(base);
List<String> literal = List.of("a", "b");

base.add("c");
元のリスト     : [a, b, c]
unmodifiable   : [a, b, c]   <- 元の変更が見える
copyOf         : [a, b]   <- 見えない
List.of        : [a, b]
unmodifiableList に add → UnsupportedOperationException
copyOf に add → UnsupportedOperationException
List.of に add → UnsupportedOperationException

unmodifiableList のJavadocは「変更不可のビュー」と書き、問い合わせは元のリストへ「read through(透過的に読み取る)」します。だから元のリストが変わると、ビューの中身も変わります。List.copyOf は、その時点の要素をコピーして不変リストにするので、あとから元を変えても影響を受けません。

観点List.of(...)Collections.unmodifiableList(x)List.copyOf(x)
何を返すか新しい不変リストx の読み取り専用ビューx の不変コピー
元の変更が見えるか元がない見える見えない
null 要素不可(NullPointerException)元が持っていれば可不可(NullPointerException)
追加できる版Java 9古くからあるJava 10
向いている場面定数の一覧内部のリストを読み取り専用で見せる受け取ったリストを防御的にコピー

追加された版は、List.of が9、List.copyOf が10と、List のJavadocのSince表記に合わせています。

null の違いも実際に確かめました。unmodifiableList は元のリストが null を持っていれば、そのまま持ちます。

List.of に null → NullPointerException
List.copyOf に null → NullPointerException
unmodifiableList は null を持てる: [a, null]
List.of(..).contains(null) → NullPointerException

最後の行が意外なところです。List.of(...) が作る不変リストに contains(null) を呼ぶと、false ではなく NullPointerException になります。null が混ざりうる値を探す処理に使うときは注意が必要です。

copyOfはコピーしないことがある

List.copyOf のJavadocには、「渡された Collection がすでに変更不可の List なら、通常はコピーを作らない」という実装ノートがあります。実行して確かめた結果です。

List.copyOf(List.of(..)) は同じ実体: true
List.copyOf(ArrayList) は別の実体   : true

「変更不可」は「中身の要素が変わらない」とは違います。リストを変更できなくても、要素が StringBuilder のような変更可能なオブジェクトなら、中身は変えられます。

要素は変えられる: [hi!]

Set と Map にも同じ系列があります。Set.of・Map.of は重複を許さず、重複があると実行時に IllegalArgumentException になります。

Set.of の重複 → IllegalArgumentException: duplicate element: 1
Map.of の重複キー → IllegalArgumentException: duplicate key: k

Stream.toList() が返すリストも変更不可です(add すると UnsupportedOperationException)。使い分けの目安は、定数なら List.of、受け取った引数を保持するなら List.copyOf、内部のリストを外から読ませるだけなら unmodifiableList です。List の基本的な作り方はJava List使い方の記事にもあります。

Java 21のSequencedCollectionで先頭と末尾が書きやすくなった

Java 21で、順序(出現順)が決まっているコレクションの共通の親として SequencedCollection・SequencedSet・SequencedMap が追加されました。Javadocは、SequencedCollection を「出現順が明確に決まっていて、両端の操作ができ、逆順にできるコレクション」と説明しています。

先頭・末尾・逆順の新しいメソッド

追加されたメソッドは、addFirst・addLast・getFirst・getLast・removeFirst・removeLast・reversed の7つです。これまでの「最後の要素を取る」は list.get(list.size() - 1) と書いていました。

List<String> list = new ArrayList<>(List.of("a", "b", "c"));
System.out.println(list.get(list.size() - 1));          // 従来
System.out.println(list.getFirst() + " / " + list.getLast());  // Java 21以降
list.addFirst("z");
list.addLast("y");
List<String> rev = list.reversed();
get(size()-1): c
getFirst / getLast: a / c
addFirst/addLast 後: [z, a, b, c, y]
reversed: [y, c, b, a, z]

reversed() はコピーではなく、元のコレクションの逆順の「ビュー」です。ビューへの変更は元に書き戻されます。

reversed に add 後の元: [end, z, a, b, c, y]

rev.add("end") が、元のリストの先頭側に入りました。逆順のビューの末尾は、元のリストの先頭だからです。for (String s : list.reversed()) と書けば、逆順の拡張for文も1行で書けます。

空のときの挙動も変わります。

get(size()-1): IndexOutOfBoundsException Index -1 out of bounds for length 0
getLast(): NoSuchElementException

従来の書き方は Index -1 out of bounds と、添字の話として失敗します。getLast() は NoSuchElementException で、「空である」ことがそのまま伝わります。

順序のあるクラスとないクラス

すべてのコレクションが SequencedCollection になったわけではありません。出現順が決まっているものだけです。

TreeSet is SequencedSet: true
HashSet is SequencedCollection: false
HashMap is SequencedMap: false
LinkedHashMap is SequencedMap: true
入れ物Sequenced補足
List(ArrayList など)○addFirst などをそのまま使える
Deque(ArrayDeque など)○もともと両端の操作があった
LinkedHashSet○既にある要素を addFirst すると先頭へ移る
TreeSet○getFirst・reversed は使えるが addFirst は不可
LinkedHashMap○(SequencedMap)firstEntry・lastEntry・putFirst などが使える
HashSet・HashMap×出現順がない

TreeSet は並びが比較で決まるため、「先頭に追加」はできません。

TreeSet first/last: 1 / 3  reversed: [3, 2, 1]
TreeSet.addFirst: UnsupportedOperationException

LinkedHashSet の addFirst は、重複を許さない Set の約束との折り合いが特徴的です。すでにある要素を addFirst すると、追加ではなく先頭への移動になります(LinkedHashSet のJavadocにも、既にある要素は必要なら先頭に移動する旨の記述があります)。

LinkedHashSet first/last: one / three
addFirst 後: [zero, one, two, three]  reversed: [three, two, one, zero]
既存要素を addFirst: [three, zero, one, two]

LinkedHashMap も同様に、putFirst で先頭にキーを入れられます。

firstEntry / lastEntry: a=1 / c=3
putFirst 後: {z=0, a=1, b=2, c=3}  reversed: {c=3, b=2, a=1, z=0}
pollLastEntry: c=3 -> {z=0, a=1, b=2}

変更不可のリストでは、reversed() で逆順のビューを取り出せても、add や addFirst は UnsupportedOperationException のままです。

List.of(..).reversed(): [3, 2, 1]
List.of(..).reversed().add: UnsupportedOperationException
List.of(..).addFirst: UnsupportedOperationException

注意点は、Java 21より前のJavaでは動かないことです。プロジェクトのJavaの版が21未満なら、list.get(list.size() - 1) の書き方を続けます。

コレクションでよくある間違い6つ

ここからは、コレクションで起きやすい間違いを6つ取り上げます。どれも例外が出る、または例外が出ないまま結果だけが違う、という形で現れます。後者のほうが見つけにくいので、動かして確かめた出力を載せました。コードを写して実行すれば、同じ結果を手元で再現できます。

1. for-each中に要素を削除する

拡張for文でリストを回しながら remove すると、ConcurrentModificationException になります。

List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4));
for (Integer n : nums) {
    if (n == 2) nums.remove(n);
}
1. for-each 中の remove → ConcurrentModificationException
   removeIf 後: [1, 3]

直し方は removeIf です。nums.removeIf(n -> n % 2 == 0) なら、安全に条件で削除できます。

ハマりポイント
例外が出ないときがあるから、気づきにくい

要素が [1, 2, 3] で「後ろから2番目」の 2 を消すと、例外は出ません。イテレータの hasNext() が先に false になって、ループが終わるからです(実行して確認しました)。Javadocも、この例外は「バグを見つけるために使うもので、これに頼ったプログラムを書くのは誤り」と書いています。たまたま動いたコードを信じず、removeIf か Iterator.remove() に直します。

for 文の読み方や Iterator との違いはJava foreachの使い方で詳しく書いています。

2. remove(int)とremove(Object)を取り違える

List<Integer> では、remove(1) がインデックスの削除になります。

List<Integer> ids = new ArrayList<>(List.of(10, 20, 30, 1));
ids.remove(1);                    // インデックス1を削除
ids.remove(Integer.valueOf(1));   // 値1を削除
remove(1)           : [10, 30, 1]
remove(Integer.valueOf(1)): [10, 30]

remove(1) は値の 1 ではなく、インデックス 1 の 20 を消しました。値で消したいときは Integer.valueOf(1) で明示します。

3. equalsとhashCodeを書いていないクラスをSetに入れる

HashSet は equals と hashCode で重複を判断します。自作クラスで書いていないと、同じ値の2個が別物として入ります。record は自動で両方が作られるので、この間違いを避けられます。

普通のクラス size=2 contains=false
record        size=1 contains=true

自作クラスの equals・hashCode の書き方はJava重複チェックの方法の記事に詳しくあります。record の使いどころはJavaのrecordとはで扱っています。

4. Setのキーに入れた要素を後から変える

HashSet に入れたあとで、hashCode に関わるフィールドを書き換えると、検索で見つからなくなります。

変更後 contains(k)=false size=1

要素は集合の中に残っているのに(size=1)、contains は false を返します。ハッシュ値が変わったため、探す場所が違うからです。Set の要素と Map のキーには、変更しない(不変の)オブジェクトを使います。

5. TreeSetは比較結果が0なら同じ要素として扱う

TreeSet は equals ではなく、compareTo(または Comparator)の結果で重複を判断します。長さだけで比較する Comparator を渡すと、同じ長さの別の文字列が消えます。

Set<String> byLength = new TreeSet<>(Comparator.comparingInt(String::length));
byLength.addAll(List.of("apple", "grape", "fig"));
長さで比較する TreeSet: [fig, apple]

apple と grape は同じ長さ5なので、片方しか残りません。TreeSet のJavadocも、順序は equals と整合している必要があり、整合しない場合は Set の一般契約を満たさなくなると書いています。

6. Arrays.asListにint配列を渡す

前の節でも出てきましたが、Arrays.asList(new int[]{1, 2, 3}).size() は 3 ではなく 1 です。int[] が要素の1個になるためで、コンパイルエラーにもならないので気づきにくい間違いです。Integer[] か Arrays.stream(...).boxed().toList() を使います。

コレクションの先に読む記事

地図を持ったら、気になった入れ物から個別の記事に進めます。

学習全体の順番は、Java入門ロードマップで確認できます。

よくある質問

Javaのコレクションについて、検索でよく見かける疑問をまとめました。使い分けの基準は、本文の「3つの質問」で決まります。細かい挙動は各見出しの実行結果もあわせて確認してください。

Q1. Javaのコレクションとは何ですか?

A1. 複数のオブジェクトをまとめて扱う入れ物と、その操作を揃えた仕組み(コレクションフレームワーク)です。List・Set・Queue・Deque・Map を軸に、ArrayList や HashMap などの実装クラスが用意されています。中身の実装に依存せず操作できるので、List 型の変数に ArrayList でも LinkedList でも入れられます。

Q2. List・Set・Mapの違いは何ですか?

A2. List は順番を持ち、重複を許します。Set は重複を許しません。Map はキーと値のペアで持ちます。Map だけは Collection を継承しない別の系統です。

Q3. ArrayListとLinkedListはどちらを使えばいいですか?

A3. 迷ったら ArrayList です。ArrayList のJavadocは、定数倍のコストが LinkedList より低いと書いています。キューやスタックにしたいなら、LinkedList ではなく ArrayDeque を選びます。

Q4. HashMapとTreeMapの違いは何ですか?

A4. HashMap は並び順を保証せず、get・put が定数時間(ハッシュが適切に散る前提)です。TreeMap はキーの比較順に並び、get・put は log(n) 時間が保証されます。順序が要らなければ HashMap、キー順が必要なら TreeMap です。

Q5. 配列とArrayListの違いは何ですか?

A5. 配列は長さが固定で、基本型(int など)をそのまま持てます。ArrayList は要素の追加で伸び、持てるのは参照型だけです。件数が変わるデータは ArrayList、長さが決まっていて基本型を持ちたい場合は配列が向きます。

Q6. List.ofとCollections.unmodifiableListの違いは何ですか?

A6. List.of は新しい不変リストを作ります。Collections.unmodifiableList は元のリストの読み取り専用ビューで、元のリストが変わるとビューの中身も変わります。元から切り離したコピーが欲しいときは List.copyOf です。

Q7. Java 21で追加されたSequencedCollectionとは何ですか?

A7. 出現順が決まっているコレクションの共通の親です。getFirst()・getLast()・addFirst()・reversed() などが使えます。List・Deque・LinkedHashSet・TreeSet が該当し、HashSet と HashMap は対象外です。

Q8. Java Silverにコレクションは出ますか?

A8. Java SE 17 Programmer I(1Z0-825-JPN)の公式チェックリストには、配列と ArrayList の使用があります。HashSet や HashMap の細かい操作は、確認できたチェックリストには載っていません。受験前にOracleの試験ページで範囲を確かめてください。

まとめ|迷ったらArrayList・HashMap・HashSetから始める

コレクション選びは、並び順・重複・取り出し方の3つの質問で入れ物を決め、そのあとで実装クラスを選びます。

【要点まとめ】

  • 番号で取り出す・順に回すなら List(ArrayList)、重複を許さないなら Set(HashSet)、名前で引くなら Map(HashMap)
  • 順序を残すなら LinkedHash~、ソートするなら Tree~、スタック・キューなら ArrayDeque
  • Map は Collection を継承しない。PriorityQueue を println しても取り出し順は見えない
  • 変更不可は List.of(新規)・copyOf(コピー)・unmodifiableList(元のビュー)で違う
  • Java 21以降は getFirst()・getLast()・reversed() で先頭・末尾の操作が書きやすい

どれを選んでも動くコードは書けます。差が出るのは、あとから要件が変わったとき、順序の仮定が崩れたとき、null が混ざったときです。そこで効くのが、この記事の表です。

NEXT STEP
いま書いているコードの new ArrayList か new HashMap を1つ選び、3つの質問を当ててみる。

並び順・重複・取り出し方に答えて、今の選択が合っているか確かめます。違うと分かったら、この記事の表から選び直してください。

途中経過は、また書きます。

NEXT READ本棚から1本

AIで開発を組み直すなら、まずこの5冊から

入門・実践・設計まで、Claude Codeの本をレベル別に5冊選んで比べました。

→ おすすめ5冊を見る

トム

SESで約8年、環境を変えられないもどかしさの中にいました。32歳で自社開発企業に転職し、今はClaude Codeと自動化で、仕事も時間も組み直している途中です。
・Javaバックエンドエンジニア(Java歴12年以上)
・資格:基本情報技術者/応用情報技術者/Java Silver/Python3エンジニア認定基礎
詳細なプロフィール

𝕏

Java入門

TOC