【Java】解决Java报错：UnsupportedOperationException

E绵绵

发布于 2024-06-12 07:51:46

3900

发布于 2024-06-12 07:51:46

文章被收录于专栏：编程学习之路

文章目录

引言
1. 错误详解
2. 常见的出错场景
- 2.1 不可修改的集合
- 2.2 抽象类和接口的默认实现
- 2.3 不支持的操作
3. 解决方案
- 3.1 使用支持操作的集合
- 3.2 提供具体实现
- 3.3 检查对象类型和能力
4. 预防措施
- 4.1 使用接口而非实现类
- 4.2 编写防御性代码
- 4.3 使用工厂方法创建集合
5. 示例项目
- 5.1 项目结构
- 5.2 Main.java
- 5.3 CustomList.java
- 5.4 pom.xml
6. 单元测试
- 6.1 MainTest.java
结语

引言

在Java编程中，UnsupportedOperationException 是一种常见的运行时异常，通常发生在尝试对不支持操作的对象调用某些方法时。这类错误提示为：“UnsupportedOperationException: operation is not supported”，意味着程序试图执行某个对象不支持的操作。本文将详细探讨UnsupportedOperationException的成因、解决方案以及预防措施，帮助开发者理解和避免此类问题，从而提高代码的健壮性和可靠性。

1. 错误详解

UnsupportedOperationException 是一种由 Java 运行时环境抛出的异常，表示程序试图对不支持的对象执行特定操作。该异常是 RuntimeException 的子类，不属于受检异常，因此无需显式捕获，但仍需要在代码中进行适当的处理。

2. 常见的出错场景

2.1 不可修改的集合

尝试修改由 Collections.unmodifiableList、Collections.unmodifiableSet 或 Collections.unmodifiableMap 返回的不可修改集合时，会抛出该异常。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
        List<String> unmodifiableList = Collections.unmodifiableList(list);
        unmodifiableList.add("D");  // 尝试修改不可修改的集合，将抛出UnsupportedOperationException
    }
}

2.2 抽象类和接口的默认实现

抽象类或接口提供的默认实现可能抛出 UnsupportedOperationException，提醒开发者需要提供具体实现。

import java.util.AbstractList;

public class Main {
    public static void main(String[] args) {
        List<String> customList = new CustomList<>();
        customList.add("A");  // 尝试调用未实现的方法，将抛出UnsupportedOperationException
    }
}

class CustomList<E> extends AbstractList<E> {
    @Override
    public E get(int index) {
        return null;
    }

    @Override
    public int size() {
        return 0;
    }
}

2.3 不支持的操作

某些类明确不支持某些操作，例如，Collections.unmodifiableList 返回的列表不支持添加或删除操作。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C");
        ListIterator<String> iterator = list.listIterator();
        iterator.remove();  // 尝试对不支持删除操作的列表进行删除，将抛出UnsupportedOperationException
    }
}

3. 解决方案

解决UnsupportedOperationException的关键在于确保对象支持所执行的操作，并在必要时提供合适的实现。

3.1 使用支持操作的集合

确保使用的集合支持所需的操作。如果需要修改集合，避免使用不可修改的集合。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
        list.add("D");  // 修改可修改的集合
        System.out.println(list);
    }
}

3.2 提供具体实现

在抽象类或接口中，提供具体实现以支持所需的操作，避免抛出 UnsupportedOperationException。

import java.util.AbstractList;

public class Main {
    public static void main(String[] args) {
        List<String> customList = new CustomList<>();
        customList.add("A");  // 正确调用已实现的方法
        System.out.println(customList.get(0));
    }
}

class CustomList<E> extends AbstractList<E> {
    private final List<E> list = new ArrayList<>();

    @Override
    public E get(int index) {
        return list.get(index);
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean add(E e) {
        return list.add(e);
    }
}

3.3 检查对象类型和能力

在执行操作之前，检查对象是否支持所需的操作。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C");

        if (list instanceof ArrayList) {
            list.add("D");  // 检查对象类型，确保支持添加操作
        } else {
            System.out.println("该集合不支持添加操作");
        }
    }
}

4. 预防措施

4.1 使用接口而非实现类

尽量使用接口而不是具体的实现类，以便灵活替换不同的实现类，避免 UnsupportedOperationException。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
        modifyList(list);
    }

    public static void modifyList(List<String> list) {
        list.add("D");  // 使用接口类型，便于替换实现类
        System.out.println(list);
    }
}

4.2 编写防御性代码

在执行操作之前，编写防御性代码，以确保对象支持所需的操作。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C");

        if (isModifiable(list)) {
            list.add("D");  // 进行防御性检查，确保对象支持添加操作
        } else {
            System.out.println("该集合不支持添加操作");
        }
    }

    public static boolean isModifiable(List<?> list) {
        try {
            list.add(null);
            list.remove(list.size() - 1);
            return true;
        } catch (UnsupportedOperationException e) {
            return false;
        }
    }
}

4.3 使用工厂方法创建集合

使用工厂方法创建集合，确保返回的集合支持所需的操作。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = createModifiableList();
        list.add("D");
        System.out.println(list);
    }

    public static List<String> createModifiableList() {
        return new ArrayList<>(Arrays.asList("A", "B", "C"));
    }
}

5. 示例项目

以下是一个示例项目，展示如何正确使用集合和方法实现，避免UnsupportedOperationException。

5.1 项目结构

myproject
├── src
│   └── main
│       └── java
│           ├── Main.java
│           └── CustomList.java
└── pom.xml

5.2 Main.java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = createModifiableList();
        list.add("D");
        System.out.println(list);

        List<String> customList = new CustomList<>();
        customList.add("A");
        System.out.println(customList.get(0));
    }

    public static List<String> createModifiableList() {
        return new ArrayList<>(Arrays.asList("A", "B", "C"));
    }
}

5.3 CustomList.java

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.List;

public class CustomList<E> extends AbstractList<E> {
    private final List<E> list = new ArrayList<>();

    @Override
    public E get(int index) {
        return list.get(index);
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean add(E e) {
        return list.add(e);
    }
}

5.4 pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>1.0-SNAPSHOT</version>
</project>

6. 单元测试

编写单元测试来验证集合操作的正确性，确保代码在各种边界条件下都能正确运行。

6.1 MainTest.java

import org.junit.Test;
import java.util.List;
import static org.junit.Assert.*;

public class MainTest {
    @Test
    public void testCreateModifiableList() {
        List<String> list = Main.createModifiableList();
        assertNotNull(list);
        list.add("D");
        assertEquals(4, list.size());
   

 }

    @Test(expected = UnsupportedOperationException.class)
    public void testUnmodifiableList() {
        List<String> list = List.of("A", "B", "C");
        list.add("D");  // 尝试修改不可修改的集合，将抛出UnsupportedOperationException
    }

    @Test
    public void testCustomList() {
        CustomList<String> customList = new CustomList<>();
        customList.add("A");
        assertEquals("A", customList.get(0));
    }
}