简介
Arrays.asList()在平时开发中比较常见，可以使用它将一个数组转换位List集合
1
2
3
4
5
|
String[] myArray = { "apple", "banana", "orange" };
List<String> myList = Arrays.asList(myArray);
//等价于
List<String> myList = Arrays.asList("apple", "banana", "orange");
|
JDK源码中对这个方法的说明
1
2
3
4
5
6
7
|
/**
* 返回由指定数组支持的固定大小的列表。此方法作为基于数组和基于集合的API之间的桥梁，与Collection.toArray()结合使用
* 返回的List是可序列化并实现RandomAccess接口。
*/
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
|
《阿里巴巴Java开发手册》对其的描述
Arrays.asList() 将数组转换为集合后，底层其实还是数组，描述如下：
使用注意事项
传递的数组必须是对象数组，而不是基本类型
Arrays.asList()是泛型方法，传入的对象必须是对象数组
1
2
3
4
5
6
7
8
9
|
int[] myArray = { 1, 2, 3 };
List myList = Arrays.asList(myArray);
System.out.println(myList.size()); //1
System.out.println(myList.get(0)); //数组地址值
System.out.println(myList.get(1)); //报错，ArrayIndexOfBoundsException
int [] array = (int[]) myList.get(0);
System.out.println(array[0]); //1
|
当传入一个原生数据类型数组时，Array.asList()真正得到的参数不是数组中的元素，而是数组对象本身！此时List的唯一元素就是这个数组。
使用包装类型数组可以解决这个问题。
1
|
Integer[] myArray = { 1, 2, 3 };
|
使用集合的修改方法：add(), remove(), clear() 会抛出异常。
1
2
3
4
|
List myList = Arrays.asList(1, 2, 3);
myList.add(4); //运行时报错， UnsupportedOperationException
myList.remove(1); //运行时报错， UnsupportedOperationException
myList.clear(); //运行时报错， UnsupportedOperationException
|
Arrays.asList()方法返回的并不是java.util.ArrayList，而是java.util.Arrays的一个内部类，这个内部类并没有实现集合的修改方法或者说并没有重写这些方法
1
2
|
List myList = Arrays.asList(1, 2, 3);
System.out.println(myList.getClass()); //class java.util.Arrays $ArrayList
|
下面是java.util.Arrays $ArrayList的简易源码，可以看到这个类重写的方法有哪些？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable
{
...
@Override
public E get(int index) {
...
}
@Override
public E set(int index, E element) {
...
}
@Override
public int indexOf(Object o) {
...
}
@Override
public boolean contains(Object o) {
...
}
@Override
public void forEach(consumer<? super E> action) {
...
}
@Override
public void replaceAll(UnaryOperator<E> operator) {
...
}
@Override
public void sort(Comparator<? super E> c) {
...
}
@Override
public E remove(int index) {
throw new UnsupportedOperationException();
}
//这里可以看到调用remove方法，会抛出UnsupportedOperationException.
}
|
如何正确的将数组转换为ArrayList
1
2
3
4
5
6
7
8
9
10
|
//JDK1.5+
static <T> List<T> arrayToList(final T[] array) {
final List<T> l = new ArrayList<T>(array.length);
for(final T s: array) {
l.add(s);
}
return (l);
}
|
1
2
|
Integer [] myArray = { 1, 2, 3 };
System.out.println(arrayToList(myArray).getClass()); //class java.util.ArrayList
|
1
|
List list = new ArrayList<>(Arrays.asList("a", "b", "c"));
|
1
2
3
4
5
6
|
Interger[] myArray = { 1, 2, 3 };
List myList = Arrays.stream(myArray).collect(Collectors.toList());
//基本类型也可以实现转换（依赖boxed的装箱操作）
int[] myArray2 = { 1, 2, 3};
List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList());
|
对于不可变集合，可以使用ImmutableList类及其of()与copeOf()工厂方法：（参数不能为空）
1
2
|
List<String> il = ImmutableList.of("string", "elements"); //from varargs
List<String> il = ImmutableList.copeOf(aStringArray); //from array
|
对于可变集合，可以使用Lists类及其newArrayList()工厂方法：
1
2
3
|
List<String> l1 = Lists.newArrayList(anotherListOrCollection); //from collection
List<String> l2 = Lists.newArrayList(aStringArray); //from array
List<String> l3 = Lists.newArrayList("or", "String", "elements"); //from varags
|
- 使用Apache Commons Collections
1
2
|
List<String> list = new ArrayList<String>();
CollectionUtils.addAll(list, str);
|
Collection.toArray()方法使用问题及反转数组
该方法是一个泛型方法： T[] toArray(T[] a);如果toArray方法中没有传递任何参数的话，返回的是Object类型数组
1
2
3
4
5
6
7
|
String[] = new String[] {
"dog", "fox", "pig"
};
List<String> list = Arrays.asList(s);
Collection.reverse(list);
s = list.toArray(new String[0]); //没有指定类型的话会报错。
|
由于JVM优化，new String[0] 作为Collection.toArray()方法的参数现在使用更好，new String[0] 就是一个模板的作用，指定了返回数组的类型，0是为了节省空间，因为只是为了说明返回的类型
详细见https://shipilev.net/blog/2016/arrays-wisdom-ancients/
不要在foreach循环里进行元素的remove/add操作。
如果要进行remove操作，可以调用迭代器的remove方法而不是集合类的remove方法。因为如果列表在任何时间从结构上修改创建迭代器之后，以任何方式除非通过迭代器自身remove/add方法，迭代器都将抛出一个ConcurrentModificationException,这就是单线程状态下产生的fail-fast机制。
fail-fast机制： 多个线程对fail-fast集合进行修改时，可能会抛出ConcurrentModificationException，单线程也会出现这种情况。
java.util包下面的所有的集合类都是fail-fast的。而java.util.concurrent包下面的所有类型都是fail-safe的
参考资料
好的软件的作用是让复杂的东西看起来简单。
