JavaのListの削除とは、remove(位置か値を指定して1件)、removeIf(条件に合うものすべて)、removeAll(指定した値すべて)、clear(全件)などのメソッドで要素を取り除く操作です。 1件だけ消すなら remove、条件でまとめて消すなら removeIf を使うのが基本で、ループの中で消したいときも、ほとんどの場合は removeIf の1行で済みます。
この記事では、拡張for文の中で削除すると ConcurrentModificationException が出る様子と、Integer のリストで remove(1) と remove(Integer.valueOf(1)) の結果が変わる様子を、実行結果つきで再現します。 そのうえで remove / removeIf / removeAll / Iterator / 逆順for / stream の filter を「用途・元リストを変更するか・例外の有無」で比べる早見表を置き、List.of() や Arrays.asList で出る UnsupportedOperationException まで扱います。コードはすべて OpenJDK 21.0.10 で実行し、出力をそのまま載せています。
Listの削除方法の早見表
| 方法 | 用途 | 元リストを変更するか | 例外の有無 |
|---|---|---|---|
list.remove(int index) |
位置を指定して1件削除 | 変更する | 範囲外の位置は IndexOutOfBoundsException |
list.remove(Object o) |
値を指定して最初の1件を削除 | 変更する | 見つからなければ false を返すだけ |
list.removeIf(条件) |
条件に合う要素をすべて削除 | 変更する | 走査中の削除でも例外にならない |
list.removeAll(コレクション) |
指定した値に一致する要素をすべて削除 | 変更する | 引数が null なら NullPointerException |
list.retainAll(コレクション) |
指定した値だけを残す | 変更する | 同上 |
list.clear() |
全件削除 | 変更する | なし |
list.subList(from, to).clear() |
位置の範囲を削除 | 変更する | 範囲外は IndexOutOfBoundsException |
Iterator の remove() |
ループで1件ずつ見ながら削除 | 変更する | next() の前に呼ぶと IllegalStateException |
逆順の for 文 + remove(i) |
位置を使いながら削除 | 変更する | なし(昇順だと位置がずれる) |
拡張for文の中で list.remove |
使わない | 途中まで変更される | ConcurrentModificationException |
stream().filter(条件).toList() |
残す要素だけの新しいリストを作る | 変更しない | なし(結果のリストは変更できない) |
List.of() や Arrays.asList() で作ったリストは、上のどの削除メソッドでも UnsupportedOperationException になります(後半で再現します)。
迷ったときの選び方は次の3つです。
- 条件に合うものを消す →
removeIf - 1件だけ消す →
remove(Integer のリストはInteger.valueOfで値を指定) - 元のリストを残したい →
stream().filter(...)で新しいリストを作る
基本の削除メソッドを動かす
まず、基本のメソッドをひととおり動かします。RemoveBasic.java として保存し、java RemoveBasic.java で実行できます。
import java.util.ArrayList;
import java.util.List;
public class RemoveBasic {
public static void main(String[] args) {
List<String> list = new ArrayList<>(List.of("A", "B", "A", "C", "D"));
String removed = list.remove(0); // 位置で削除(戻り値は削除した要素)
System.out.println(removed + " " + list);
boolean found = list.remove("A"); // 値で削除(最初の1件だけ。戻り値は削除できたか)
System.out.println(found + " " + list);
System.out.println(list.remove("Z") + " " + list); // 無い値は false(例外にならない)
list.removeIf(s -> s.equals("C")); // 条件で削除(Java 8 以降)
System.out.println(list);
list.removeAll(List.of("B", "X")); // 指定した値をすべて削除
System.out.println(list);
list.clear(); // 全部削除
System.out.println(list + " " + list.isEmpty());
}
}
実行結果(OpenJDK 21.0.10):
A [B, A, C, D]
true [B, C, D]
false [B, C, D]
[B, D]
[D]
[] true
remove(int) の戻り値は削除した要素、remove(Object)・removeIf・removeAll の戻り値は「リストが変わったかどうか」の真偽値です。
remove("A") で消えるのは最初の1件だけという点が、最初につまずきやすいところです。同じ値をすべて消したいときは removeIf(s -> s.equals("A")) か removeAll(List.of("A")) を使います。
remove(int)とremove(Object)の違い
List には remove という名前のメソッドが2つあります。位置を受け取る remove(int index) と、値を受け取る remove(Object o) です。文字列のリストでは迷いませんが、List<Integer> では「1」が位置なのか値なのかで結果が変わります。
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class IntRemove {
public static void main(String[] args) {
List<Integer> a = new ArrayList<>(List.of(10, 1, 20, 1));
Integer removed = a.remove(1); // remove(int index):位置1を削除
System.out.println("remove(1) -> 戻り値 " + removed + " / " + a);
a = new ArrayList<>(List.of(10, 1, 20, 1));
boolean ok = a.remove(Integer.valueOf(1)); // remove(Object o):値1を削除
System.out.println("remove(Integer.valueOf(1)) -> 戻り値 " + ok + " / " + a);
a = new ArrayList<>(List.of(10, 1, 20, 1));
Integer boxed = 1;
a.remove(boxed); // Integer 型の変数なら値で削除
System.out.println("Integer型の変数で remove -> " + a);
a = new ArrayList<>(List.of(10, 1, 20, 1));
a.remove((Object) 1); // Object にキャストしても値で削除
System.out.println("remove((Object) 1) -> " + a);
Collection<Integer> col = new ArrayList<>(List.of(10, 1, 20));
col.remove(1); // Collection 型には remove(int) がない
System.out.println("Collection型で remove(1) -> " + col);
List<Integer> b = new ArrayList<>(List.of(10, 1, 20));
try {
b.remove(20); // 値20のつもりが「位置20」
} catch (IndexOutOfBoundsException e) {
System.out.println("remove(20) -> " + e);
}
List<Character> chars = new ArrayList<>(List.of('a', 'b', 'c'));
try {
chars.remove('a'); // char は int に広がる('a' は 97)
} catch (IndexOutOfBoundsException e) {
System.out.println("List<Character>.remove('a') -> " + e);
}
List<Long> longs = new ArrayList<>(List.of(1L, 2L));
System.out.println("List<Long>.remove(1L) -> " + longs.remove(1L) + " / " + longs);
}
}
実行結果:
remove(1) -> 戻り値 1 / [10, 20, 1]
remove(Integer.valueOf(1)) -> 戻り値 true / [10, 20, 1]
Integer型の変数で remove -> [10, 20, 1]
remove((Object) 1) -> [10, 20, 1]
Collection型で remove(1) -> [10, 20]
remove(20) -> java.lang.IndexOutOfBoundsException: Index 20 out of bounds for length 3
List<Character>.remove('a') -> java.lang.IndexOutOfBoundsException: Index 97 out of bounds for length 3
List<Long>.remove(1L) -> true / [2]
元のリストは [10, 1, 20, 1] です。
remove(1)は位置1(2番目)の要素を削除しました。たまたま位置1の値が 1 だったので戻り値も 1 ですが、これは「削除した要素」が返っているだけです。remove(Integer.valueOf(1))は値 1 を探して、最初の1件を削除しました。戻り値は true です。- 今回の例は位置1に値1を置いたので、残ったリストはどちらも
[10, 20, 1]で同じに見えます。違いは戻り値(1 と true)と、次のremove(20)の例ではっきりします。 値 20 を消すつもりでremove(20)と書くと「位置20」と解釈され、IndexOutOfBoundsException になりました。
| 書き方 | 呼ばれるメソッド | 意味 |
|---|---|---|
list.remove(1)(int のリテラルや int 型の変数) |
remove(int index) |
位置1の要素を削除 |
list.remove(Integer.valueOf(1)) |
remove(Object o) |
値1の最初の1件を削除 |
list.remove((Object) 1) |
remove(Object o) |
値1の最初の1件を削除 |
| Integer 型の変数を渡す | remove(Object o) |
値で削除 |
Collection<Integer> 型の変数で remove(1) |
remove(Object o) |
Collection には位置指定の remove がないので値で削除 |
List<Character> で remove('a') |
remove(int index) |
char が int に広がり、位置97として扱われる |
なぜこうなるのか:Java は、引数の型がそのまま一致するメソッドを先に選びます。int の 1 を渡すと、int をそのまま受け取れる remove(int) が選ばれ、Integer への自動変換(オートボクシング)が必要な remove(Object) は選ばれません。Integer 型の値を渡したときだけ remove(Object) になります。
List<Integer> から値で消したいときは、list.removeIf(n -> n == 20) のように removeIf で書くと取り違えが起きません(removeIf は一致する要素をすべて削除します)。
拡張for文で削除するとConcurrentModificationExceptionになる
ループしながら条件に合う要素を消そうとして、次のように書くことがあります。
import java.util.ArrayList;
import java.util.List;
public class CmeDemo {
public static void main(String[] args) {
List<String> names = new ArrayList<>(List.of("A", "B", "C", "D"));
for (String name : names) {
if (name.equals("B")) {
names.remove(name);
}
}
System.out.println(names);
}
}
実行結果:
Exception in thread "main" java.util.ConcurrentModificationException
at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1095)
at java.base/java.util.ArrayList$Itr.next(ArrayList.java:1049)
at CmeDemo.main(CmeDemo.java:7)
names.remove(name) を実行した次の周回で、ConcurrentModificationException が出て止まりました。 スタックトレースを見ると、例外が出ているのは remove の行ではなく、次の要素を取り出す ArrayList$Itr.next の中(checkForComodification)です。
例外が出るしくみ
拡張for文は、内部で Iterator(要素を順に取り出すためのしくみ)を使っています。ArrayList は「これまでに構造が何回変更されたか」という回数を持っていて、Iterator はループを始めた時点の回数を覚えています。next() のたびに両方を比べ、Iterator を通さずにリストが変更されていたら「走査中に別のところから変更された」と判断して例外を出します。 走査中の変更に早めに気付けるようにするための安全装置です。
名前に Concurrent(並行)と付いていますが、スレッドが1つだけのプログラムでも起こります。
例外が出ないまま1件読み飛ばすこともある
同じ書き方でも、消す位置によっては例外が出ません。また、拡張for文以外でも同じ例外になる場面があります。
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CmeMore {
static void t(String label, Runnable r) {
try {
r.run();
System.out.println(label + " => 例外なし");
} catch (RuntimeException e) {
System.out.println(label + " => " + e.getClass().getName());
}
}
public static void main(String[] args) {
// 1. 最後から2番目の要素を削除すると、例外が出ないまま1件読み飛ばす
List<String> names = new ArrayList<>(List.of("A", "B", "C", "D"));
int count = 0;
for (String name : names) {
count++;
if (name.equals("C")) names.remove(name);
}
System.out.println("Cを削除 -> " + names + " / ループ回数 " + count);
// 2. 拡張for以外でも、走査中に同じリストを変更すると同じ例外になる
List<String> l1 = new ArrayList<>(List.of("A", "B", "C", "D"));
t("forEach の中で remove", () -> l1.forEach(x -> { if (x.equals("B")) l1.remove(x); }));
List<String> l2 = new ArrayList<>(List.of("A", "B", "C", "D"));
t("拡張for の中で add", () -> { for (String x : l2) l2.add("Z"); });
List<String> l3 = new ArrayList<>(List.of("A", "B", "C", "D"));
t("removeIf の条件の中で remove", () -> l3.removeIf(x -> { l3.remove("D"); return false; }));
Map<String, Integer> map = new HashMap<>(Map.of("a", 1, "b", 2, "c", 3));
t("HashMap の keySet ループ中に remove", () -> { for (String k : map.keySet()) map.remove(k); });
// 3. 昇順の for 文は例外にならないが、削除のたびに位置がずれる
List<Integer> nums = new ArrayList<>(List.of(1, 2, 2, 3, 4, 4));
for (int i = 0; i < nums.size(); i++) {
if (nums.get(i) % 2 == 0) nums.remove(i);
}
System.out.println("昇順for で偶数を削除 -> " + nums);
}
}
実行結果:
Cを削除 -> [A, B, D] / ループ回数 3
forEach の中で remove => java.util.ConcurrentModificationException
拡張for の中で add => java.util.ConcurrentModificationException
removeIf の条件の中で remove => java.util.ConcurrentModificationException
HashMap の keySet ループ中に remove => java.util.ConcurrentModificationException
昇順for で偶数を削除 -> [1, 2, 3, 4]
- 最後から2番目の「C」を削除した場合は例外が出ず、ループは3回で終わりました。 削除でリストの長さが3になり、Iterator が「もう次の要素はない」と判断してループを抜けるためです。最後の「D」は一度も調べられていません。たまたま動いているだけなので、テストのデータによって結果が変わる原因になります。
- forEach の中、拡張for文の中での add、removeIf の条件の中での remove、HashMap のループ中の remove でも、同じ例外になりました。 「走査している最中に、同じコレクションを直接変更する」ことが共通点です。
- 昇順の for 文(位置で回す書き方)は例外になりませんが、結果が
[1, 2, 3, 4]となり、偶数が残りました。 削除すると後ろの要素が前に詰まるので、詰まってきた要素を調べないまま次の位置へ進んでしまうためです。
ループ中に削除する7つの書き方
うまく削除できる書き方を並べます。どれも [1, 2, 2, 3, 4, 4] から偶数を取り除く処理です。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;
public class LoopOk {
static List<Integer> data() {
return new ArrayList<>(List.of(1, 2, 2, 3, 4, 4));
}
public static void main(String[] args) {
// 1. removeIf(いちばん短い)
List<Integer> a = data();
boolean changed = a.removeIf(n -> n % 2 == 0);
System.out.println("1 removeIf " + a + " 戻り値 " + changed);
// 2. Iterator の remove(削除しながら別の処理もしたいとき)
List<Integer> b = data();
for (Iterator<Integer> it = b.iterator(); it.hasNext(); ) {
Integer n = it.next();
if (n % 2 == 0) {
it.remove(); // b.remove(n) ではなく it.remove()
}
}
System.out.println("2 Iterator " + b);
// 3. 逆順の for 文(位置を使いたいとき)
List<Integer> c = data();
for (int i = c.size() - 1; i >= 0; i--) {
if (c.get(i) % 2 == 0) c.remove(i);
}
System.out.println("3 逆順for " + c);
// 4. 昇順の for 文で、削除したら i を1つ戻す
List<Integer> d = data();
for (int i = 0; i < d.size(); i++) {
if (d.get(i) % 2 == 0) {
d.remove(i);
i--;
}
}
System.out.println("4 昇順for + i-- " + d);
// 5. stream の filter(元のリストは変えず、残すものだけの新しいリストを作る)
List<Integer> e = data();
List<Integer> odd = e.stream().filter(n -> n % 2 != 0).toList(); // toList() は Java 16 以降
System.out.println("5 stream filter " + odd + " 元 " + e);
// 6. 新しいリストをあとで変更したいとき
List<Integer> odd2 = e.stream().filter(n -> n % 2 != 0).collect(Collectors.toCollection(ArrayList::new));
odd2.add(9);
System.out.println("6 toCollection " + odd2);
// 7. 削除する対象を別のリストに集めてから removeAll
List<Integer> f = data();
List<Integer> targets = new ArrayList<>();
for (Integer n : f) {
if (n % 2 == 0) targets.add(n);
}
f.removeAll(targets);
System.out.println("7 集めてremoveAll " + f);
}
}
実行結果:
1 removeIf [1, 3] 戻り値 true
2 Iterator [1, 3]
3 逆順for [1, 3]
4 昇順for + i-- [1, 3]
5 stream filter [1, 3] 元 [1, 2, 2, 3, 4, 4]
6 toCollection [1, 3, 9]
7 集めてremoveAll [1, 3]
| 番号 | 書き方 | 向いている場面 | 気を付ける点 |
|---|---|---|---|
| 1 | removeIf |
条件で消すだけ。まずこれを検討する | 条件の中で同じリストを変更しない |
| 2 | Iterator の remove() |
消しながら、要素ごとに別の処理もしたい | list.remove ではなく it.remove() を呼ぶ。next() 1回につき1回だけ |
| 3 | 逆順の for 文 | 位置(何番目か)を使って判断したい | i は size() - 1 から 0 まで |
| 4 | 昇順の for 文 + i-- |
既存の昇順ループを最小限の変更で直したい | 戻し忘れると読み飛ばす |
| 5 | stream().filter().toList() |
元のリストを残したい | 条件は「残すもの」を書く。結果は変更できないリスト |
| 6 | Collectors.toCollection(ArrayList::new) |
新しいリストをあとで変更したい | 5より少し長い |
| 7 | 対象を集めてから removeAll |
削除対象を先に確定させたい | 同じ値の要素はまとめて消える |
removeIf と filter は条件の向きが逆です。removeIf は「消すもの」の条件、filter は「残すもの」の条件を書きます。偶数を取り除くなら、removeIf は n % 2 == 0、filter は n % 2 != 0 です。
逆順の for 文で位置がずれない理由は、後ろから見ていけば、削除で詰まるのが「すでに調べ終わった側」だけになるからです。
件数が多いときの時間の違い
20万件のリストから偶数(10万件)を取り除く時間を、4つの書き方で計測しました。
各方法とも、0〜199,999 の整数を入れた ArrayList を用意し、System.nanoTime で削除の前後の時刻を取って差を出しています。これを3回くり返しました(計測用のコードは LoopOk.java の1・2・3・5と同じ書き方で、掲載は省略します)。
実行結果(OpenJDK 21.0.10、Linux amd64、2コアの検証用コンテナ。System.nanoTime による簡易計測で、数値は環境や実行のたびに変わります):
removeIf 9.99 ms / Iterator 815.28 ms / 逆順for 400.57 ms / stream filter 6.73 ms (残り 100000,100000,100000,100000)
removeIf 5.26 ms / Iterator 802.19 ms / 逆順for 403.11 ms / stream filter 2.30 ms (残り 100000,100000,100000,100000)
removeIf 1.35 ms / Iterator 803.13 ms / 逆順for 392.57 ms / stream filter 1.52 ms (残り 100000,100000,100000,100000)
- removeIf と stream の filter は数ミリ秒、Iterator と逆順の for 文は数百ミリ秒でした。
- ArrayList は1件削除するたびに後ろの要素を前へ詰めます。Iterator や for 文は「1件消して詰める」を10万回くり返すのに対し、ArrayList の removeIf は残す要素をまとめて詰め直すので、件数が多いほど差が開きます。
- 逆順の for 文が Iterator より速いのは、後ろから消すと詰める量が少なくて済むためです。
- 数百件程度のリストなら、どの書き方でも体感できる差にはなりません。読みやすさの面でも removeIf が第一候補になります。
目的別の削除コード集
「こういう消し方をしたい」から探せる逆引き表です。
| 番号 | やりたいこと | 書き方 |
|---|---|---|
| 1 | 指定した値をすべて削除 | list.removeAll(List.of(2, 4)) |
| 2 | 指定した値だけ残す | list.retainAll(List.of(2, 4)) |
| 3 | 位置の範囲を削除 | list.subList(1, 3).clear() |
| 4 | 先頭と末尾を削除(Java 21 以降) | list.removeFirst()、list.removeLast() |
| 5 | 先頭と末尾を削除(Java 20 以前でも可) | list.remove(0)、list.remove(list.size() - 1) |
| 6 | null をすべて削除 | list.removeIf(Objects::isNull) |
| 7 | null を1件だけ削除 | list.remove(null) |
| 8 | 空文字・空白だけの要素を削除 | list.removeIf(String::isBlank) |
| 9 | 重複を削除(順番は保つ) | new ArrayList<>(new LinkedHashSet<>(list)) |
| 10 | ある値をすべて削除 | list.removeAll(Collections.singleton("A")) |
| 11 | オブジェクトのフィールドを条件に削除 | items.removeIf(it -> it.qty() == 0) |
| 12 | 同じ内容のオブジェクトを削除 | items.remove(new Item("note", 5)) |
| 13 | Map を値の条件で削除 | map.values().removeIf(v -> v == 0) |
| 14 | Map をキーの条件で削除 | map.entrySet().removeIf(...) |
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Objects;
import java.util.TreeMap;
import java.util.Map;
public class Recipes {
record Item(String name, int qty) {}
static List<Integer> data() {
return new ArrayList<>(List.of(1, 2, 2, 3, 4, 4));
}
public static void main(String[] args) {
List<Integer> n;
n = data(); n.removeAll(List.of(2, 4)); // 指定した値をすべて削除
System.out.println("1 " + n);
n = data(); n.retainAll(List.of(2, 4)); // 指定した値だけ残す
System.out.println("2 " + n);
n = data(); n.subList(1, 3).clear(); // 位置1〜2(3は含まない)を削除
System.out.println("3 " + n);
n = data(); n.removeFirst(); n.removeLast(); // 先頭と末尾を削除(Java 21 以降)
System.out.println("4 " + n);
n = data(); n.remove(0); n.remove(n.size() - 1); // 先頭と末尾を削除(Java 20 以前でも可)
System.out.println("5 " + n);
List<String> s = new ArrayList<>(Arrays.asList("A", null, "B", null));
s.removeIf(Objects::isNull); // null をすべて削除
System.out.println("6 " + s);
s = new ArrayList<>(Arrays.asList("A", null, "B", null));
s.remove(null); // null を1件だけ削除
System.out.println("7 " + s);
s = new ArrayList<>(Arrays.asList("A", "", " ", "B"));
s.removeIf(String::isBlank); // 空文字・空白だけの要素を削除(Java 11 以降)
System.out.println("8 " + s);
List<String> dup = new ArrayList<>(List.of("B", "A", "B", "C", "A"));
List<String> unique = new ArrayList<>(new LinkedHashSet<>(dup)); // 重複を削除(順番は保つ)
System.out.println("9 " + unique);
dup.removeAll(Collections.singleton("A")); // 値Aをすべて削除
System.out.println("10 " + dup);
List<Item> items = new ArrayList<>(List.of(new Item("pen", 0), new Item("note", 5), new Item("tape", 0)));
items.removeIf(it -> it.qty() == 0); // オブジェクトのフィールドを条件に削除
System.out.println("11 " + items);
System.out.println("12 " + items.remove(new Item("note", 5)) + " " + items); // equals が一致すれば削除
Map<String, Integer> stock = new TreeMap<>(Map.of("pen", 0, "note", 5, "tape", 0));
stock.values().removeIf(v -> v == 0); // Map を値の条件で削除
System.out.println("13 " + stock);
stock.entrySet().removeIf(en -> en.getKey().startsWith("n")); // Map をキーの条件で削除
System.out.println("14 " + stock);
}
}
実行結果:
1 [1, 3]
2 [2, 2, 4, 4]
3 [1, 3, 4, 4]
4 [2, 2, 3, 4]
5 [2, 2, 3, 4]
6 [A, B]
7 [A, B, null]
8 [A, B]
9 [B, A, C]
10 [B, B, C]
11 [Item[name=note, qty=5]]
12 true []
13 {note=5}
14 {}
補足です。
- 3の subList(1, 3) は「位置1から、位置3の手前まで」です。
[1, 2, 2, 3, 4, 4]の位置1と2(2 と 2)が消えました。 - 4の removeFirst / removeLast は Java 21 で List に追加されたメソッドです(Java 21 の List の API ドキュメントで Since: 21 と確かめました)。空のリストで呼ぶと NoSuchElementException になります。
- 8の isBlank は null に対して呼ぶと NullPointerException になるので、null が混ざる可能性があるときは
s -> s == null || s.isBlank()と書きます(この条件式は今回未実行です)。 - 12の remove(Object) は equals で比べます。record は全フィールドが等しければ equals が true になるので、同じ内容の別インスタンスでも削除できました。自作のクラスで同じことをするには、equals(と hashCode)を定義しておきます。
- 13と14 のように、Map も values() や entrySet() に対する removeIf で、条件に合う組を安全に削除できます。
List.ofやArrays.asListでUnsupportedOperationExceptionになる
メソッドの使い方は合っているのに UnsupportedOperationException が出るときは、リストそのものが「変更できないリスト」か「長さを変えられないリスト」になっています。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Unsupported {
static void t(String label, Runnable r) {
try {
r.run();
System.out.println(label + " => 例外なし");
} catch (RuntimeException e) {
System.out.println(label + " => " + e.getClass().getName());
}
}
public static void main(String[] args) {
t("List.of(1, 2, 3).remove(0)", () -> List.of(1, 2, 3).remove(0));
t("List.of(1, 2, 3).removeIf(一致あり)", () -> List.of(1, 2, 3).removeIf(x -> x > 1));
t("List.of(1, 2, 3).removeIf(一致なし)", () -> List.of(1, 2, 3).removeIf(x -> x > 100));
t("Arrays.asList(1, 2, 3).remove(0)", () -> Arrays.asList(1, 2, 3).remove(0));
t("Arrays.asList(1, 2, 3).removeIf(一致あり)", () -> Arrays.asList(1, 2, 3).removeIf(x -> x > 1));
t("Arrays.asList(1, 2, 3).removeIf(一致なし)", () -> Arrays.asList(1, 2, 3).removeIf(x -> x > 100));
t("Arrays.asList(1, 2, 3).clear()", () -> Arrays.asList(1, 2, 3).clear());
t("Arrays.asList(1, 2, 3).set(0, 99)", () -> Arrays.asList(1, 2, 3).set(0, 99));
t("Collections.unmodifiableList(...).remove(0)", () -> Collections.unmodifiableList(new ArrayList<>(List.of(1))).remove(0));
t("List.copyOf(...).remove(0)", () -> List.copyOf(new ArrayList<>(List.of(1))).remove(0));
t("stream.toList().remove(0)", () -> Stream.of(1, 2).toList().remove(0));
t("stream.collect(Collectors.toList()).remove(0)", () -> Stream.of(1, 2).collect(Collectors.toList()).remove(0));
t("new ArrayList<>(List.of(1, 2, 3)).remove(0)", () -> new ArrayList<>(List.of(1, 2, 3)).remove(0));
t("new ArrayList<>(Arrays.asList(1, 2, 3)).remove(0)", () -> new ArrayList<>(Arrays.asList(1, 2, 3)).remove(0));
}
}
実行結果:
List.of(1, 2, 3).remove(0) => java.lang.UnsupportedOperationException
List.of(1, 2, 3).removeIf(一致あり) => java.lang.UnsupportedOperationException
List.of(1, 2, 3).removeIf(一致なし) => java.lang.UnsupportedOperationException
Arrays.asList(1, 2, 3).remove(0) => java.lang.UnsupportedOperationException
Arrays.asList(1, 2, 3).removeIf(一致あり) => java.lang.UnsupportedOperationException
Arrays.asList(1, 2, 3).removeIf(一致なし) => 例外なし
Arrays.asList(1, 2, 3).clear() => java.lang.UnsupportedOperationException
Arrays.asList(1, 2, 3).set(0, 99) => 例外なし
Collections.unmodifiableList(...).remove(0) => java.lang.UnsupportedOperationException
List.copyOf(...).remove(0) => java.lang.UnsupportedOperationException
stream.toList().remove(0) => java.lang.UnsupportedOperationException
stream.collect(Collectors.toList()).remove(0) => 例外なし
new ArrayList<>(List.of(1, 2, 3)).remove(0) => 例外なし
new ArrayList<>(Arrays.asList(1, 2, 3)).remove(0) => 例外なし
| リストの作り方 | 削除できるか | 要素の入れ替え(set) |
|---|---|---|
new ArrayList<>(...) |
できる | できる |
List.of(...)、List.copyOf(...) |
UnsupportedOperationException | できない |
Arrays.asList(...) |
UnsupportedOperationException(長さを変えられない) | できる |
Collections.unmodifiableList(...) |
UnsupportedOperationException | できない |
stream.toList()(Java 16 以降) |
UnsupportedOperationException | できない |
stream.collect(Collectors.toList()) |
今回の実行ではできた | 今回は未確認 |
- Arrays.asList は配列を包んだ固定長のリストです。配列は長さを変えられないので、削除や追加はできませんが、set での入れ替えはできます。
- 条件に合う要素が1つもないとき、Arrays.asList の removeIf は例外になりませんでした。 実際に削除が起きたときにだけ例外が出るので、データによって動いたり止まったりします。List.of のほうは、一致する要素がなくても例外になりました。
- Collectors.toList() の結果は、今回の Java 21 では削除できましたが、返されるリストの種類や変更できるかどうかは保証されていません。変更する予定があるなら
Collectors.toCollection(ArrayList::new)を使います。
直し方は、new ArrayList<>(List.of(1, 2, 3)) のように変更できるリストへコピーしてから削除することです。 コピーしたリストで remove(0) が例外にならないことは、上の実行結果の最後の2行で確かめています。メソッドの引数で受け取ったリストは、呼び出し側がどう作ったかわかりません。受け取ったリストを直接削除するよりも、filter で新しいリストを作って返すほうが、作り方に左右されない書き方になります。
そのほかの例外と対処
削除まわりで出るほかの例外も再現しておきます。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Others {
static void t(String label, Runnable r) {
try {
r.run();
System.out.println(label + " => 例外なし");
} catch (RuntimeException e) {
System.out.println(label + " => " + e);
}
}
public static void main(String[] args) {
List<Integer> list = new ArrayList<>(List.of(1, 2, 3));
t("next() の前に it.remove()", () -> list.iterator().remove());
t("it.remove() を2回続ける", () -> { Iterator<Integer> it = list.iterator(); it.next(); it.remove(); it.remove(); });
t("空のリストで remove(0)", () -> new ArrayList<Integer>().remove(0));
t("空のリストで removeFirst()", () -> new ArrayList<Integer>().removeFirst());
t("removeIf(null)", () -> new ArrayList<>(List.of(1)).removeIf(null));
t("removeAll(null)", () -> new ArrayList<>(List.of(1)).removeAll(null));
}
}
実行結果:
next() の前に it.remove() => java.lang.IllegalStateException
it.remove() を2回続ける => java.lang.IllegalStateException
空のリストで remove(0) => java.lang.IndexOutOfBoundsException: Index 0 out of bounds for length 0
空のリストで removeFirst() => java.util.NoSuchElementException
removeIf(null) => java.lang.NullPointerException
removeAll(null) => java.lang.NullPointerException
| 例外 | 出る場面 | 対処 |
|---|---|---|
| ConcurrentModificationException | 拡張for文・forEach の中で、同じリストを直接変更した | removeIf、Iterator の remove、filter のどれかに替える |
| UnsupportedOperationException | List.of、Arrays.asList、toList() などのリストを変更した | new ArrayList<>(...) にコピーしてから削除する |
| IndexOutOfBoundsException | 無い位置を指定した。Integer のリストで値のつもりの数値を渡した | 位置の範囲を確かめる。値なら Integer.valueOf か removeIf |
| IllegalStateException | Iterator で next() の前や、続けて2回 remove() を呼んだ | next() 1回につき remove() は1回まで |
| NoSuchElementException | 空のリストで removeFirst / removeLast を呼んだ | 先に isEmpty() を確かめる |
| NullPointerException | removeIf や removeAll に null を渡した | 引数が null にならないようにする |
どの方法を選ぶかの判断表
| 状況 | 選ぶ方法 |
|---|---|
| 位置がわかっている1件を消す | remove(index) |
| 値がわかっている1件を消す | remove(値)。Integer のリストは remove(Integer.valueOf(値)) |
| 条件に合うものをすべて消す | removeIf(条件) |
| 別のリストに入っている値をすべて消す | removeAll(コレクション) |
| 位置の範囲をまとめて消す | subList(from, to).clear() |
| 消しながら、要素ごとに別の処理もする | Iterator の remove() |
| 何番目かを使って判断する | 逆順の for 文 |
| 元のリストはそのまま残す | stream().filter(残す条件).toList() |
| 受け取ったリストが変更できるかわからない | filter で新しいリストを作る、または ArrayList にコピーする |
| 全部消す | clear() |
よくある質問
Q. removeとremoveIfはどう使い分けますか? A. remove は位置か値を指定して1件だけ削除します。removeIf は条件に合う要素をすべて削除します。同じ値が複数あってすべて消したい場合や、「0以下」「空文字」のような条件で消したい場合は removeIf を使います。
Q. 拡張for文の中で削除したいときはどう書けばよいですか?
A. 拡張for文をやめて list.removeIf(条件) に置き換えるのが最も短い書き方です。消しながら別の処理もしたいときは Iterator を使い、it.remove() で削除します。拡張for文の中で list.remove を呼ぶと、次の周回で ConcurrentModificationException になります。
Q. Integerのリストで、値を指定して削除するにはどうしますか?
A. list.remove(Integer.valueOf(1)) と書きます。list.remove(1) と書くと位置1の要素が削除されます。値で消す意図がはっきり伝わる list.removeIf(n -> n == 1) もおすすめです(こちらは一致する要素をすべて削除します)。
Q. removeIfで元のリストを変えたくない場合はどうしますか?
A. removeIf は元のリストを変更するメソッドです。元を残したいときは list.stream().filter(残す条件).toList() で新しいリストを作ります。toList() の結果は変更できないので、あとで追加や削除をするなら Collectors.toCollection(ArrayList::new) で受け取ります。
まとめ
- 1件だけ消すなら remove、条件でまとめて消すなら removeIf が基本です。remove(値) で消えるのは最初の1件だけです。
List<Integer>の remove(1) は位置1の削除です。値で消すときはremove(Integer.valueOf(1))か removeIf を使います。- 拡張for文の中で list.remove を呼ぶと ConcurrentModificationException になります。消す位置によっては例外が出ないまま1件読み飛ばします。
- ループ中の削除は removeIf、Iterator の remove、逆順の for 文、stream の filter のどれかで書きます。
- 20万件での計測では、removeIf と filter が数ミリ秒、Iterator と逆順の for 文が数百ミリ秒でした。
- List.of、Arrays.asList、toList() のリストは削除できず UnsupportedOperationException になります。
new ArrayList<>(...)にコピーしてから削除します。 - removeIf は「消す条件」、filter は「残す条件」 を書きます。
参考
- Java SE 21 API ドキュメント「Interface List」(remove・removeAll・removeFirst・removeLast と変更できないリストの説明): https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/List.html
株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。
WE ARE HIRING
RJCで一緒に開発しながら、
成長を楽しみませんか?
RJCは、Web・モバイル・AIを活用した開発プロジェクトで、テックリードやPM・PMOも活躍するシステム開発会社です。会社を知る、待遇を確かめる、話を聞いてみる。気になるところ見てみてください!
- 127日年間休日
- 12時間平均残業時間
- 毎日ガチャ遊びココロも大切にする福利厚生。アマギフなどの賞品ラインナップ!
ほかにも、チケットレストラン、書籍読み放題、2年ごとの慰労報奨(休暇 or 金一封)、11期連続の黒字決算。