前言
最近在网上看到一个问题,情况类似如下(记为问题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:数组存储异常。下面具体就集合方法与泛型探究上面的问题。
过程
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);
运行后,控制台输出如下:
我们发现,不论是修改数组,还是修改集合,另一方都会相应改变。
小结
一开始以为是一个小问题,渐渐的发现,其中内容不少,集合是我们开发中算是很常用类库了,良好的熟悉程度能对我们的开发优化不少。而泛型关联到反射等等核心内容,如果想深入学习,也需要认真下功夫,在问题的探究中往往能有更深刻的印象。