[Java] 例外：UnsupportedOperationExceptionエラーの原因と対処法

UnsupportedOperationExceptionは、サポートされていない操作が実行された際にスローされる例外です。

主な原因としては、変更不可能なコレクションに対して変更操作(追加、削除など)を行った場合や、未実装のメソッドが呼び出された場合が挙げられます。

例えば、Arrays.asList()で作成されたリストは固定サイズのため、要素の追加や削除ができません。

対処法としては、変更可能なコレクションを使用するか、未実装のメソッドを適切に実装することが必要です。

この記事でわかること

UnsupportedOperationExceptionの概要
発生する主な原因
具体的な発生例
例外の対処法
コレクション操作の注意点

目次から探す

UnsupportedOperationExceptionとは

UnsupportedOperationExceptionは、Javaプログラミングにおいて、特定の操作がサポートされていない場合にスローされる例外です。

この例外は、主に不変コレクションや未実装のメソッドを呼び出した際に発生します。

たとえば、Collections.unmodifiableList()メソッドで生成されたリストに対して要素を追加しようとすると、この例外が発生します。

UnsupportedOperationExceptionは、プログラムの実行時に発生するため、適切に処理しないとアプリケーションがクラッシュする原因となります。

この例外を理解し、適切に対処することは、Javaプログラミングにおいて重要なスキルです。

UnsupportedOperationExceptionが発生する主な原因

不変コレクションに対する変更操作

不変コレクションは、作成後に要素を変更できないコレクションです。

例えば、Collections.unmodifiableList()メソッドを使用して生成されたリストに対して、要素の追加や削除を試みると、UnsupportedOperationExceptionがスローされます。

このようなコレクションは、データの整合性を保つために使用されますが、変更を試みるとエラーが発生します。

未実装のメソッド呼び出し

抽象クラスやインターフェースで定義されたメソッドが未実装の場合、そのメソッドを呼び出すとUnsupportedOperationExceptionが発生します。

これは、開発者が意図的にそのメソッドを実装していないことを示すための手段です。

未実装のメソッドを呼び出すことは、プログラムの設計上のミスを示すことがあります。

特定のAPIやライブラリの制約

特定のAPIやライブラリでは、特定の操作がサポートされていない場合があります。

たとえば、Javaの標準ライブラリの一部では、特定のコレクションに対して変更操作が許可されていないことがあります。

このような場合、サポートされていない操作を試みると、UnsupportedOperationExceptionが発生します。

Java標準ライブラリでの発生例

Java標準ライブラリには、UnsupportedOperationExceptionが発生するいくつかのメソッドがあります。

例えば、List.of()メソッドで生成されたリストは不変であり、要素の追加や削除を試みるとこの例外がスローされます。

また、Collections.singletonList()メソッドで生成されたリストも同様に、要素の変更ができません。

これらの例は、Javaのコレクションフレームワークにおける不変性の重要性を示しています。

具体的な発生例

Arrays.asList()での例外発生

Arrays.asList()メソッドは、配列をリストに変換しますが、生成されたリストは固定サイズであり、要素の追加や削除はできません。

以下のコードは、Arrays.asList()を使用してリストを作成し、要素を追加しようとした場合の例です。

import java.util.Arrays;
import java.util.List;
public class App {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C");
        
        // 要素の追加を試みる
        list.add("D"); // ここでUnsupportedOperationExceptionが発生
    }
}

Exception in thread "main" java.lang.UnsupportedOperationException

Collections.unmodifiableList()での例外発生

Collections.unmodifiableList()メソッドは、与えられたリストを不変にします。

この不変リストに対して変更操作を行うと、UnsupportedOperationExceptionが発生します。

以下のコードはその例です。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class App {
    public static void main(String[] args) {
        List<String> originalList = new ArrayList<>();
        originalList.add("A");
        originalList.add("B");
        
        List<String> unmodifiableList = Collections.unmodifiableList(originalList);
        
        // 要素の追加を試みる
        unmodifiableList.add("C"); // ここでUnsupportedOperationExceptionが発生
    }
}

Exception in thread "main" java.lang.UnsupportedOperationException

List.of()での例外発生

List.of()メソッドは、要素を持つ不変リストを生成します。

このリストに対して変更を試みると、UnsupportedOperationExceptionが発生します。

以下のコードはその例です。

import java.util.List;
public class App {
    public static void main(String[] args) {
        List<String> immutableList = List.of("A", "B", "C");
        
        // 要素の削除を試みる
        immutableList.remove("A"); // ここでUnsupportedOperationExceptionが発生
    }
}

Exception in thread "main" java.lang.UnsupportedOperationException

Map.of()での例発生

Map.of()メソッドは、不変のマップを生成します。

このマップに対して変更を試みると、UnsupportedOperationExceptionが発生します。

以下のコードはその例です。

import java.util.Map;
public class App {
    public static void main(String[] args) {
        Map<String, String> immutableMap = Map.of("key1", "value1", "key2", "value2");
        
        // 要素の追加を試みる
        immutableMap.put("key3", "value3"); // ここでUnsupportedOperationExceptionが発生
    }
}

Exception in thread "main" java.lang.UnsupportedOperationException

UnsupportedOperationExceptionの対処法

変更可能なコレクションを使用する

UnsupportedOperationExceptionを回避するための最も簡単な方法は、変更可能なコレクションを使用することです。

例えば、ArrayListやHashMapなどの可変コレクションを使用すれば、要素の追加や削除が可能です。

以下のコードは、ArrayListを使用して要素を追加する例です。

import java.util.ArrayList;
import java.util.List;
public class App {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C"); // 変更可能なコレクションに要素を追加
        System.out.println(list);
    }
}

[A, B, C]

コレクションのコピーを作成する

不変コレクションを使用する場合でも、元のコレクションのコピーを作成することで、変更可能なコレクションを得ることができます。

以下のコードは、ArrayListのコピーを作成し、要素を追加する例です。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class App {
    public static void main(String[] args) {
        List<String> originalList = List.of("A", "B", "C"); // 不変リスト
        List<String> modifiableList = new ArrayList<>(originalList); // コピーを作成
        
        modifiableList.add("D"); // 変更可能なリストに要素を追加
        System.out.println(modifiableList);
    }
}

[A, B, C, D]

メソッドの実装を行う

抽象クラスやインターフェースで定義されたメソッドが未実装の場合、適切に実装を行うことでUnsupportedOperationExceptionを回避できます。

以下のコードは、インターフェースのメソッドを実装する例です。

interface MyInterface {
    void myMethod(); // 未実装のメソッド
}
class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("メソッドが実装されました。");
    }
}
public class App {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.myMethod(); // メソッドを呼び出す
    }
}

メソッドが実装されました。

例外をキャッチして適切に処理する

UnsupportedOperationExceptionが発生する可能性がある場合、例外をキャッチして適切に処理することも重要です。

以下のコードは、例外をキャッチしてエラーメッセージを表示する例です。

import java.util.Collections;
import java.util.List;
public class App {
    public static void main(String[] args) {
        List<String> unmodifiableList = Collections.unmodifiableList(List.of("A", "B", "C"));
        
        try {
            unmodifiableList.add("D"); // 例外が発生する可能性がある
        } catch (UnsupportedOperationException e) {
            System.out.println("変更操作はサポートされていません: " + e.getMessage());
        }
    }
}

変更操作はサポートされていません: null

コレクション操作における注意点

不変コレクションと可変コレクションの違い

不変コレクションは、作成後に要素を変更できないコレクションです。

これに対して、可変コレクションは要素の追加、削除、変更が可能です。

以下の表は、両者の主な違いを示しています。

スクロールできます

特徴	不変コレクション	可変コレクション
変更の可否	変更不可	変更可能
パフォーマンス	高速(変更がないため)	変更時にオーバーヘッドが発生
スレッドセーフ性	自然にスレッドセーフ	明示的な同期が必要
使用例	定数リスト、設定値	データの動的管理

不変コレクションの利点と欠点

不変コレクションには、いくつかの利点と欠点があります。

利点としては、データの整合性が保たれ、スレッドセーフであるため、並行処理において安全に使用できる点が挙げられます。

一方、欠点としては、要素の変更ができないため、柔軟性に欠けることや、変更が必要な場合には新しいコレクションを作成する必要がある点があります。

変更可能なコレクションの作成方法

変更可能なコレクションを作成するには、ArrayListやHashMapなどの可変コレクションを使用します。

以下のコードは、ArrayListを使用して変更可能なリストを作成する例です。

import java.util.ArrayList;
import java.util.List;
public class App {
    public static void main(String[] args) {
        List<String> modifiableList = new ArrayList<>();
        modifiableList.add("A");
        modifiableList.add("B");
        modifiableList.add("C"); // 要素を追加
        System.out.println(modifiableList);
    }
}

[A, B, C]

コレクションのコピーとその用途

コレクションのコピーは、元のコレクションの状態を保持しつつ、新しいコレクションを作成するために使用されます。

これにより、元のコレクションを変更せずに新しいデータを追加したり、操作を行ったりできます。

以下のコードは、コレクションのコピーを作成する例です。

import java.util.ArrayList;
import java.util.List;
public class App {
    public static void main(String[] args) {
        List<String> originalList = new ArrayList<>();
        originalList.add("A");
        originalList.add("B");
        
        // コレクションのコピーを作成
        List<String> copiedList = new ArrayList<>(originalList);
        copiedList.add("C"); // コピーに要素を追加
        
        System.out.println("元のリスト: " + originalList);
        System.out.println("コピーしたリスト: " + copiedList);
    }
}

元のリスト: [A, B]
コピーしたリスト: [A, B, C]

このように、コレクションのコピーを作成することで、元のデータを保持しつつ新しい操作を行うことができます。

応用例：UnsupportedOperationExceptionの回避

カスタムコレクションの作成

カスタムコレクションを作成することで、特定の要件に応じた変更可能なコレクションを実装できます。

以下のコードは、要素の追加と削除が可能なカスタムリストを作成する例です。

import java.util.ArrayList;
import java.util.List;
class CustomList<T> {
    private List<T> list = new ArrayList<>(); // 内部でArrayListを使用
    public void add(T element) {
        list.add(element); // 要素を追加
    }
    public void remove(T element) {
        list.remove(element); // 要素を削除
    }
    public List<T> getList() {
        return list; // リストを返す
    }
}
public class App {
    public static void main(String[] args) {
        CustomList<String> customList = new CustomList<>();
        customList.add("A");
        customList.add("B");
        customList.remove("A"); // 要素を削除
        System.out.println(customList.getList());
    }
}

[B]

メソッドのオーバーライドによる例外回避

抽象クラスやインターフェースのメソッドをオーバーライドすることで、UnsupportedOperationExceptionを回避できます。

以下のコードは、抽象クラスのメソッドをオーバーライドして実装する例です。

abstract class AbstractOperation {
    abstract void performOperation(); // 抽象メソッド
}
class ConcreteOperation extends AbstractOperation {
    @Override
    void performOperation() {
        System.out.println("操作が実行されました。"); // メソッドを実装
    }
}
public class App {
    public static void main(String[] args) {
        ConcreteOperation operation = new ConcreteOperation();
        operation.performOperation(); // メソッドを呼び出す
    }
}

操作が実行されました。

サードパーティライブラリの活用

サードパーティライブラリを活用することで、UnsupportedOperationExceptionを回避するための便利な機能を利用できます。

例えば、Apache Commons CollectionsやGuavaなどのライブラリは、柔軟なコレクション操作を提供しています。

以下のコードは、Guavaライブラリを使用して不変リストを作成し、変更可能なリストを生成する例です。

import com.google.common.collect.Lists;
import java.util.List;
public class App {
    public static void main(String[] args) {
        List<String> immutableList = List.of("A", "B", "C"); // 不変リスト
        List<String> modifiableList = Lists.newArrayList(immutableList); // Guavaを使用して変更可能なリストを作成
        
        modifiableList.add("D"); // 要素を追加
        System.out.println(modifiableList);
    }
}