来源：https://www.cnblogs.com/young-z/p/8465198.html
最近在网上看到一个问题，情况类似如下（记为问题1）：
-
public
class Demo {
-
-
public static void main(String[] args) {
-
System.out.println(testInteger(
1));
-
System.out.println(testInt(
1));
-
}
-
-
public static boolean testInteger (Integer num) {
-
Integer[] nums =
new Integer[]{
1,
2,
3,
4,
5,
6};
-
boolean flag = Arrays.asList(nums).contains(num);
-
return flag;
-
}
-
-
public static boolean testInt (int num) {
-
int[] nums =
new
int[]{
1,
2,
3,
4,
5,
6};
-
boolean flag = Arrays.asList(nums).contains(num);
-
return flag;
-
}
-
}
结果第一个输出为true，提问者觉得很正常，第二个输出却为false了，很奇怪。如果没有深入使用过该集合，或是理解泛型，在我的第一眼看来，也是有疑惑。按理来说，Java中本身针对基本类型与对应包装类型，就有自动装箱拆箱功能，你Integer能行，我int按理来说应该也能行。于是我大致在网上搜寻了类似的问题，发现除了上面的问题，还有类似如下的情况(记为问题2)
-
public
class
Demo2 {
-
-
public static void main(String[] args) {
-
Integer[] nums1 =
new Integer[]{
1,
2,
3,
4,
5,
6};
-
List list1 = Arrays.asList(nums1);
-
list1.
set(
0,
888);
-
System.
out.println(list1);
-
-
int[] nums2 =
new
int[]{
1,
2,
3,
4,
5,
6};
-
List list2 = Arrays.asList(nums2);
-
list2.
set(
0,
888);
-
System.
out.println(list2);
-
}
-
-
}
第一个输出正常，集合list1中第一个元素修改为888，但是第二输出还没到就已经报错，完整运行结果如下：
java.lang.ArrayStoreException：数组存储异常。下面具体就集合方法与泛型探究上面的问题。
java.lang.ArrayStoreException：数组存储异常。下面具体就集合方法与泛型探究上面的问题。
过程
Integer[] nums = new Integer[]{1, 2, 3, 4, 5, 6};
Arrays.asList(nums);进入这个方法，源代码如下：
-
public
static <T>
List<T> asList(T... a) {
-
return
new ArrayList<>(a);
-
}
短短的两行代码，内容却并不简单
1.方法的参数比较特殊：参数是泛型类的，并且是可变参数。一个泛型，一个可变参数，说实话，初学者或者开发中不敢说都没用过，但要是说有多常用，显然也不符合。所以其实上面的内容在这一步就已经出问题了，下面会具体分析。
2.方法的返回值是一个ArrayList,这里又是一个大坑，这个ArrayList并不是我们以前学习或者平时常用到的有序集合ArrayList，而是数组工具类Arrays类的一个静态内部类，继承了AbstractList，如下所示：
-
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) {
-
//上面调用的构造方法内容即为这里，调用requireNonNull方法，对象array为空的话会报空指针异常，不为空则将其赋值给成员a。
-
a = Objects.requireNonNull(array);
-
}
-
-
//赋值后此时a就代表了array数组的内容，所以后面的方法基本上都围绕a展开。
-
-
@Override
-
public int size() {
-
return a.length;
-
}
-
-
@Override
-
public Object[] toArray() {
-
return a.clone();
-
}
-
......
-
-
}
requireNonNull方法内容：
-
public
static <T>
T requireNonNull(T obj) {
-
if (obj ==
null)
-
throw
new NullPointerException();
-
return obj;
-
}
完整的过完了这一遍流程后，我们要思考的是，通过Arrays.asList（nums）方法，我们得到的到底是一个什么。从上面的内容，我们首先可以确定是一个集合。在问题1中，包装类Integer情况下，调用Arrays.asList(nums)，基于可变参数的定义，这里我们相当于传入可变参数的长度为5。
在public static <T> List<T> asList(T... a)方法中，此时相当于泛型T指定为Integer类型。然后private final E[] a; 此时的数组a的泛型E也相应为Integer。此时a的内容相当于 new Integer[]{1,2,3,4,5,6}; 即一个Integer类型的一维数组，集合也随之为List<Integer>
最后获取的是一个Arrays的一个静态内部类ArrayList对象，在内部类中重写了contains方法：
-
@Override
-
public boolean contains(Object o) {
-
return indexOf(o) != -
1;
-
}
所以在问题1中的第一种情况传入1时会自动转为对象Object类型，即上面的o，此时显然成立，所以返回true。
那么第二种情况输出false，问题出在哪里？
在基本类型int情况时，同样基于可变参数的定义，同时基于java的自动转换类型，跟上面一样传入可变参数的长度还是相当于5吗？其实不是，根本原因在于这里除了可变参数的定义，还有泛型的定义，但是别忘了泛型也有一些限制,首先第一点就是：
泛型的类型参数只能是类类型（包括自定义类），不能是简单类型！
所以这里其实就已经有分歧了，所以这里我们相当于传入了一个对象，对象类型为数组类型，可变参数的长度是1，而不是5。此时a相当于一个二维数组，在上面的情况中，即a数组的元素类型为数组，元素个数为1，而不是上面的Integer,此时集合为List<int[]>。
最后得到的集合是这样子：List<int[]>形式,集合长度为1，包含了一个数组对象，而不是误以为的List<Intger>。
接着调用contains方法，集合中就一个数组类型对象，显然不包含1。所以问题1中int情况下输出false
同样的，在问题2的int情况下，list2.set(0,888);即相当于将集合索引为0的元素（即第1个，这里集合中就一个数组元素）赋值为一个888自动转型的Integer类，给1个数组Array类型对象赋值Intger对象，所以才报错了上面的数组存储异常。
梳理与验证
为了更好的理清上面的内容，做如下扩展。
首先是Integer对象类型。
-
Integer[] nums =
new Integer[]{
1,
2,
3,
4,
5,
888};
-
List<Integer> list2 = Arrays.asList(nums);
-
System.
out.println(list2.
get(
5));
//输出888
这里我们顺利的通过一次索引拿到在这个888。
接着是int基本类型，前面提到了既然是可变参数，我们传了一个数组，一个数组也是一个对象，那我们可以传入多个数组看看，如下所示。
-
int[] nums1 =
new
int[]{
1,
2,
3,
4,
5,
666};
-
int[] nums2 =
new
int[]{
1,
2,
3,
4,
5,
777};
-
int[] nums3 =
new
int[]{
1,
2,
3,
4,
5,
888};
-
List<
int[]> list1 = Arrays.asList(nums1,nums2,nums3);
-
System.
out.println(list1.
get(
2)[
5]);
//输出888
这里的get方法我们点进去查看源代码：
-
@Override
-
public E get(int index) {
-
return a[index];
-
}
所以这里我们输出其实就是a[2][5],拿到888，这也印证了前面为什么说本质上就是一个二维数组的原因，同时加深了我们对集合与数组关系的理解。
更多的陷阱
前面重点提到这里我们通过Arrays.asList()方法得到的"ArrayList"，并不是我们平时常用的那个ArrayList，既然强调了，当然是为了要区分，那么不区分会有什么问题呢，下面以简单的Integer情况为例：
-
Integer[] nums =
new Integer[]{
1,
2,
3,
4,
5};
-
List<Integer>
list = Arrays.asList(nums);
-
list.add(
888);
-
System.out.println(
list);
集合后面加个888，觉得会打印出来什么？【1, 2, 3, 4, 5，888】？
然后事实是还没到打印就已经抛出异常了，如下所示：
java.lang.UnsupportedOperationException：不支持的操作异常。为什么会不支持，我们以前一直add，remove等等都没问题。深究到底查看源代码。
首先java.util包下的ArrayList即我们熟知的，它的add方法实现如下：
-
public boolean add(E e) {
-
ensureCapacityInternal(size +
1);
// Increments modCount!!
-
elementData[size++] = e;
-
return
true;
-
}
这也是我们一直以来操作没毛病的原因。
再来看这个"ArrayLitst",它在继承抽象类AbstractList的时候，并未实现（或者准确来说叫做重写）add方法，所以这里在调用add方法的时候，实际上是调用的抽象类AbstractList中已经实现的add方法，我们来看其方法内容：
-
public boolean add(E e) {
-
add(size(), e);
-
return
true;
-
}
通过add(size(), e);这个传入2个参数的方法我们继续查看内容：
-
public void add(int index, E element) {
-
throw
new UnsupportedOperationException();
-
}
真相大白！throw new UnsupportedOperationException();这个异常从哪来的一目了然。这个"ArrayLitst"根本没有实现add方法，所以才会报错。回到初始，还能想起集合与数组的种种关联，数组本身长度就是不可变的，而这里本质上我们就是在操作数组，所以没有add方法不是很正常吗。仔细查看其类的源码，会发现例如remove删除等方法，也是没有实现的，所以同样也会报错。
继续探讨，那么这里增也不行，删也不行，那我改总行吧，就数组而言，按理来说应该是支持的，而实际情况也的确如此。在"ArrayLitst"内部类中，其重写了set方法，方法能将指定索引处的元素修改为指定值，同时将旧元素的值作为返回值返回。
-
@
Override
-
public E
set(int
index, E element)
{
-
E oldValue = a[index];
-
a[index] = element;
-
return oldValue;
-
}
但是这里还要注意一点，如果我们在这里针对集合修改了某处元素值，那么原来数组的内容也会相应改变！即通过Arrays.asList()方法，得到的集合与原数组就已经关联起来，反之，如果我们修改了数组内容，那么集合获取到的内容也会随之改变。实践检验一下：
-
Integer[] nums =
new Integer[]{
1,
2,
3,
4,
5};
-
List<Integer>
list = Arrays.asList(nums);
-
list.set(
0,
888);
//修改集合内容
-
nums[
1] =
999;
//修改数组内容
-
for(Integer i:nums) {
-
System.out.println(i);
-
}
-
System.out.println(
list);
运行后，控制台输出如下：
我们发现，不论是修改数组，还是修改集合，另一方都会相应改变。
小结
一开始以为是一个小问题，渐渐的发现，其中内容不少，集合是我们开发中算是很常用类库了，良好的熟悉程度能对我们的开发优化不少。而泛型关联到反射等等核心内容，如果想深入学习，也需要认真下功夫，在问题的探究中往往能有更深刻的印象。