Arrays.asList() 返回的list不能add,remove以及慎用java.util.Collections.copy()方法

今天在搜索数组和集合对象相互转化的问题时，发现了一些有趣的问题，在此和大家进行共勉~如有不合适的地方望更正。

1、如果只是想将数组转换成List，可以用JDK中的java.util.Arrays类：

import java.util.Arrays;   
String[] strArray = {"aaa", "bbb", "ccc"};   
List strList = Arrays.asList(strArray);  
不过Arrays.asList()方法返回的List不能add对象，因为该方法的实现是使用参数引用的数组的大小来new的一个ArrayList，后面将会详细解答。

2、Collection转数组
直接使用Collection的toArray()方法，该方法有两个重载版本：

Object[] toArray();   
T[] toArray(T[] a);

集合转数组、数组转集合实例代码：

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

public class TestMain {
 
 public static void main(String[] args) {
  List<User> list = new ArrayList<TestMain.User>();
  User user1 = new User();
  user1.setId(1L);
  list.add(user1);
  
  User user2 = new User();
  user2.setId(2L);
  list.add(user2);
  
  User[] userArray = list.toArray(new User[0]);
  for(User u : userArray) {
   System.out.println(u.getId());
  }
  
  List<User> userList = Arrays.asList(userArray);
  for(User u : userList) {
   System.out.println(u.getId());
  }
 }

 public static class User {
  private Long id;

  public Long getId() {
   return id;
  }

  public void setId(Long id) {
   this.id = id;
  }

 }
}

好了，回到刚才的问题，我们都知道，List的一个典型的特性就是其长度是可变的，我们可以很方便地对它进行插入和删除元素的操作，这是它与数组所存在的一个很大的区别，后者的长度是固定的，而且我们不能从数组中删除元素，只能修改元素的值。利用Arrays.asList(array)将返回一个List，然而这个返回的List并不支持add和remove的操作。

public static void main(String[] args) {  
        List<Integer> list = Arrays.asList(1,2,3);  
        list.add(5);  
        System.out.print(list.toString());  
    }  

上面的代码会报异常：Exception in thread "main" java.lang.UnsupportedOperationException

Arrays.asList源码：

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

这里的ArrayList并不是java.util.ArrayList，而是Arrays的内部类。

终其原因是Arrays.asList方法返回的ArrayList是继承自AbstractList同时实现了RandomAccess和Serializable接口，定义如下： 

private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable

我们再来看看AbstractList这个类的定义：  

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>

我们可以看到该内部类继承的是AbstractList，下面是AbstractList的add和remove方法源码：

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

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

public E remove(int index) {
        throw new UnsupportedOperationException();
    }

所以，当我们对Arrays.asList返回的List进行添加或删除时将会报 java.lang.UnsupportedOperationException 异常。

通过上面的分析，我们知道，其实通过asList方法得到的List是只读的，那么平时我们怎样避免这样的错误发生？我们可以采用如下方法：  

List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3));  

--------------------------------------------------------华丽的分割线------------------------------------------------------------------

好了，接下来我们来看慎用java.util.Collections.copy()方法

copy(List<? super T>, List<? extends T>) 方法用于将所有从一个列表中的元素复制到另一个。

下面的例子显示java.util.Collections.copy()方法的使用

public class CollectionsDemo {
   public static void main(String args[]) {
      // create two lists    
      List<String> srclst = new ArrayList<String>(5);
      List<String> destlst = new ArrayList<String>(10);
      
      // populate two lists
      srclst.add("Java");
      srclst.add("is");
      srclst.add("best");
      
      destlst.add("C++");
      destlst.add("is");
      destlst.add("older");
      
      
      // copy into dest list
      Collections.copy(destlst, srclst);            
      
      System.out.println("Value of source list: "+srclst);
      System.out.println("Value of destination list: "+destlst);
   }    
}

现在编译和运行上面的代码示例，将产生以下结果：

Value of source list: [Java, is, best]
Value of destination list: [Java, is, best]

今天发现单独的将一个ArrayList的对象添加到另外一个ArrayList的时候，总是源列表和目的列表相同的内存地址。原因如下：

偶然看到了Collections的copy（List desc,List src）方法。当时就想这个方法和初始化一个List desc=new ArrayList(List c)【参数必须实现Collection接口】的区别。
两者的差别很大，后者是一个浅拷贝，只是对源list的元素进行拷贝，拷贝的只是引用。拷贝后两个list的元素（引用）不同，但是引用所指向的对象是一样的。即是两个list的每个元素指向的还是同一内存。然而前者是深拷贝，不光拷贝的是src的元素（引用），src内每个元素的所指向的对象都进行一次拷贝。即是两个list的每个元素所指向的不是同一内存。

所以使用了Collections.copy()方法来进行拷贝，但是这样就接触到了此方法所报出的异常。

使用后者进行拷贝的结果是：当你的desc链表发生改变时，src也将会随之改变。
使用前者进行拷贝时你又必须要注意目标链表的长度必须要比源链表的长度大或者相等。

List src1 = new ArrayList(3);
		src1.add("a");
		src1.add("b");
		src1.add("c");
List des1=new ArrayList(3);

Collections.copy(des1,src1);

将会出错，抛出数组越界异常。
当时我怎么想都想不明白为什么，明明已经设置了长度为3，为什么还会出错！
后来打印出des1.size()才知道des1的长度为0；3表示的是这个List的容纳能力为3，并不是说des1中就有了3个元素。查看api才知道，它的capacity（容纳能力大小）可以指定（最好指定）。而初始化时size的大小永远默认为0，只有在进行add和remove等相关操作时，size的大小才变化。然而进行copy()时候，首先做的是将desc1的size和src1的size大小进行比较，只有当desc1的size 大于或者等于src1的size时才进行拷贝，否则抛出IndexOutOfBoundsException异常。

这是copy方法源码：

/**
     * Copies all of the elements from one list into another.  After the
     * operation, the index of each copied element in the destination list
     * will be identical to its index in the source list.  The destination
     * list must be at least as long as the source list.  If it is longer, the
     * remaining elements in the destination list are unaffected. <p>
     *
     * This method runs in linear time.
     *
     * @param  dest The destination list.
     * @param  src The source list.
     * @throws IndexOutOfBoundsException if the destination list is too small
     *         to contain the entire source List.
     * @throws UnsupportedOperationException if the destination list's
     *         list-iterator does not support the <tt>set</tt> operation.
     */
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator();
            ListIterator<? extends T> si=src.listIterator();
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }

所以可以通过下面的方法指定目标desc的大小

List des1=new ArrayList(Array.asList(new object[src1.size]));//注意：new ArrayList(Collection col)参数必须要实现Collection 接口。
Collections.copy(des1,src1);

执行第一句后size的大小是3，其实它是对一个空数组的浅拷贝。