探讨UnsupportedOperationException的原因及解决方案

最近工作中老给同事挖坑，真是愧疚。上周五写了个接口给同事用，结果同事用的时候告诉我报错，我一看，是UnsupportedOperationException，有点懵，没明白这是为啥。当时只是在网上找解决方法，没有细究错误出现的原因，今天有时间把这个整明白，记录于此。

1、 示例代码及错误信息
下面是我工作时写的错误代码的简化版：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Created by Herry on 2017/7/2.
 */
public class TestArrayToList {

    public static void main(String[] args) {
        String[] ordinaryArray = {"11", "22", "33"};
        // (1)
        List<String> transferedArray = Arrays.asList(ordinaryArray);
        // (2)
        transferedArray.add("66");

        // (3)
        List<String> myList = new ArrayList<>();
    }

}

错误信息：

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.add(AbstractList.java:148)
    at java.util.AbstractList.add(AbstractList.java:108)
    at com.liu.date20170702.TestArrayToList.main(TestArrayToList.java:17)

2、 分析
根据提示信息，我们可以找到错误出现在标记(2)处，就是调用add()方法时抛出了异常。我们顺着堆栈信息往上找，提示的是AbstractList类的108行出了异常，这一行所在方法的具体实现如下：

public boolean add(E e) {
        add(size(), e);
        return true;
    }

出现异常的第108行调用了add()方法，于是继续寻找这个add()方法的实现，具体如下：

public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }

到这里我们找到了异常抛出的地方，但是如果要找到真正的原因，我们还需要看下示例代码中标记(1)处asList()方法的实现，具体如下：

public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

乍一看，懵了，这不是返回一个ArrayList吗？为什么会不知道add操作呢？别急，顺着找下去，我们发现，此ArrayList不是彼ArrayList。这个ArrayList是Arrays工具类中实现的内部静态类，跟代码中标记(3) 处的ArrayList（在java.util包中）不同。下面我们看看这个静态内部类ArrayList的实现，具体如下：

private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

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

        @Override
        public Object[] toArray() {
            return a.clone();
        }

        @Override
        @SuppressWarnings("unchecked")
        public <T> T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
                return Arrays.copyOf(this.a, size,
                                     (Class<? extends T[]>) a.getClass());
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

        @Override
        public E get(int index) {
            return a[index];
        }

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            if (o == null) {
                for (int i = 0; i < a.length; i++)
                    if (a[i] == null)
                        return i;
            } else {
                for (int i = 0; i < a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }

        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }

我们可以发现，这个类集成了AbstractList类，但是并没有重写add()方法，所以在我们的示例代码标记(2)处调用add()方法时，实际是调用父类AbstractList的add()方法，这也就回到了开头分析的那两个add()方法了，它们都没有具体实现，只会抛出UnsupportedOperationException。

3、 原因总结
到这里我们可以稍稍理清下思路了，我们调用Arrays的asList()方法将数组转换成List时返回的是Arrays的静态内部类ArrayList，它自身并未重写add()方法，而其父类AbstractList实现的add()方法只会抛出UnsupportedOperationException，导致我们调用Arrays的静态内部类ArrayList的add()方法时，实际调用的是只会抛出UnsupportedOperationException的AbstractList的add()方法，这就是异常出现的原因了。

4、 解决方案
如果你真的必须将数组转换成List的话，那就自己写个转换方法吧，可以参考一下代码：

private static <E>  List<E> transferArrayToList(E[] array){
        List<E> transferedList = new ArrayList<>();
        Arrays.stream(array).forEach(arr -> transferedList.add(arr));
        return transferedList;
}

当然，实现某个功能或许可以找到其他更好的方法，可以多转换下思路。

5、 结语
将这个遇到的问题记录于此，一来是希望自己引以为戒，二来希望对遇到问题的你有所帮助。如果以上分析有不当之处，还望各位大神指教，不胜感激！