Immutablexx原理:
只是copy了原容器本身,并不是deep copy,所以对原容器地址内容的修改也会影响到新容器
例子
@Test
public void changeOrNot(){
List listPort=Lists.newArrayList(new Port(1,1));
ImmutableList immutableList=ImmutableList.copyOf(listPort);
listPort.get(0).setSource(2);
System.out.println(listPort);
System.out.println(immutableList);
listPort.set(0,new Port(5,5));
System.out.println(listPort);
System.out.println(immutableList);
}
上述代码
发现结果 第一次更改原地址数据的值,也更新到了新集合。
但是第二次List的set方法为什么没有更新到新集合呢?
通过查看arryalist的源码发现
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
其实它并没有更改原地址数据的值,而是将引用指向了一个新的地址,即传递过来的参数。我们新集合指向的是原地址,数据并没有改变,所以信集合不会更改。同理,对原集合的add等操作也不会影响到新集合。同样,remove方法其实改变的是引用的地址,而不是地址里的对象。
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
jdk的UnmodifiableXXX方法
该方法返回不可变容器
无法修改容器内容。同样指set或者add方法修改容器内ref的指向,而不是禁止ref指向内容的修改
对原来容器的修改会影响返回的内容。比如add,remove等方法。
实际上返回的视图,通过视图查看容器内容的变更。
区别:对于immutablexx来说,原容器的add,remove方法是不会影响新容器的。因为它返回的不是原容器的视图,而是原容器的一份拷贝。(不是深拷贝)
copyOf方法源码查看
查看copyOf方法。copyOf方法将集合强制转换成guava的ImmutableCollection,然后调用他的asList方法返回。
public static ImmutableList copyOf(Collection elements) {
if (elements instanceof ImmutableCollection) {
ImmutableList list = ((ImmutableCollection)elements).asList();
return list.isPartialView() ? asImmutableList(list.toArray()) : list;
} else {
return construct(elements.toArray());
}
}
查看asList方法,发现如果是0个或1个元素,实际上是调用ImmutableList.of()方法。多个元素的话,返回的是一个新的RegularImmutableAsList对象
public ImmutableList asList() {
switch(this.size()) {
case 0:
return ImmutableList.of();
case 1:
return ImmutableList.of(this.iterator().next());
default:
return new RegularImmutableAsList(this, this.toArray());
}
}
最后再一层一层进入方法,发现其实返回的都是新的对象
RegularImmutableAsList(ImmutableCollection delegate, Object[] array) {
this(delegate, ImmutableList.asImmutableList(array));
}
static ImmutableList asImmutableList(Object[] elements, int length) {
switch(length) {
case 0:
return of();
case 1:
ImmutableList list = new SingletonImmutableList(elements[0]);
return list;
default:
if (length < elements.length) {
elements = ObjectArrays.arraysCopyOf(elements, length);
}
return new RegularImmutableList(elements);
}
}
扩展一下jdk的asList方法,这是一个坑
@Test
public void testAsList(){
int[] ints = {1,2,3,4,5};
List list = Arrays.asList(ints);
System.out.println("list'size:" + list.size());
System.out.println("list 的类型:" + list.get(0).getClass());
System.out.println("list.get(0) == ints:" + list.get(0).equals(ints));
Integer[] integers={1,2,3,4,5};
List integerList=Arrays.asList(integers);
System.out.println("list size:"+integerList.size());
System.out.println("list.get(0) 的类型:" + list.get(0).getClass());
System.out.println("list.get(0) == ints[0]:" + list.get(0).equals(ints[0]));
}
为什么调用Arrays.asList()方法,参数int数组会长度返回1?
asList 接受的参数是一个泛型的变长参数,我们知道基本数据类型是无法发型化的,也就是说 8 个基本类型是无法作为 asList 的参数的, 要想作为泛型参数就必须使用其所对应的包装类型。但是这个这个实例中为什么没有出错呢?因为该实例是将 int 类型的数组当做其参数,而在 Java 中数组是一个对象,它是可以泛型化的。所以该例子是不会产生错误的。既然例子是将整个 int 类型的数组当做泛型参数,那么经过 asList 转换就只有一个 int 的列表了。
asList源码
public static List asList(T... a) {
return new ArrayList<>(a);
}
所以,如果用asList方法,最好用基本类型包装类。
2.返回的集合无法add等操作
asList返回的ArrayList
private static class ArrayList extends AbstractList
implements RandomAccess, java.io.Serializable{
private static final long serialVersionUID = -2764017481108945198L;
private final E[] a;
ArrayList(E[] array) {
if (array==null)
throw new NullPointerException();
a = array;
}
//.................
}