开发过程中,遇到数组转List集合后在进行相关操作的时候,很多同学一定会第一时间想到这个方法@SafeVarargs @SuppressWarnings("varargs") public static <T> List<T> asList(T... a) { return new ArrayList<>(a); }
。但是这里面有三个雷区,大家一定要注意!
1.返回的并不是java.util下的ArrayList
这个方法返回的是Arrays内部自己继承AbstractList的一个内部类 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);
}
}
有没有发现什么重点?没错,就是他没有复写add/remove/clear这些方法。而调用这些方法会直接调用父类AbstractList中的add方法:
public boolean add(E e) {
add(size(), e);
return true;
}
public void add(int index, E element) {
throw new UnsupportedOperationException();
}
可以看到,这里直接会抛出一个UnsupportedOperationException的异常。是不是很惊喜。。这个一定要注意,如果要正常使用List的这些方法,需要再包一次,把他转换为util下的真正的ArrayList:
String[] str = new String[]{"1","2"};
List list = Arrays.asList(str);
ArrayList arrayList = new ArrayList<>(list);
包装类型和基本类型的数组
在Arrays.asList中,该使用的是泛型,但是基础数据类型不是对象,不存在引用的概念,直接存在内存栈上面的,所以不能用泛型,这也是List<>不能放int等基础数据类型的原因。,一般可看做数组参数,但是如果传入的是int[] 的话,也就是一个基本类型的数组,编译器会把数组泛型化,认为只传了一个变量,这个变量的类型是int数组。这个就和我们预期有出入了:
int[] data = {1,2,3,4,5};
List list = Arrays.asList(data);
System.out.println("元素类型:" + list.get(0).getClass());
System.out.println("前后是否相等:"+data.equals(list.get(0)));
可以看到,
输出的为元素类型:class [I
前后是否相等:true
所以,传入的数组一定要是包装类型,这样才能正确的转换为list:
Integer[] data = {1,2,3,4,5};
List list = Arrays.asList(data);
System.out.println("列表中的元素数量是:" + list.size());
输出结果:
列表中的元素数量是:5
说明编译器对Integer[] 处理不一样。Integer是可变长参数。传入过程中asList()方法实际是将Integer数组里的元素进行存储。
对数组的修改也会影响list
可以看Arrays的内部实现,他是把这个数组的引用直接给里面的成员:private final E[] a
,所有的操作都是针对这个数组的操作,如果更改了原数组的元素,转换后的list的对应的下角标的元素也会改变:
String[] str = new String[]{"1","2"};
List list = Arrays.asList(str);
str[0] = "unv";//那么list.get(0)也随着修改
总结
将数组转换为集合时,调用Arrays.asList这个方法后,我们尽量再包装一次new ArrayList<>(list)
,将其转换为真正的java.util.ArrayList,这样会省去很多不必要的麻烦!