Immutablexx原理：
只是copy了原容器本身，并不是deep copy，所以对原容器地址内容的修改也会影响到新容器
例子
@Test
public void changeOrNot(){
List<Port> listPort=Lists.newArrayList(new Port(1,1));
ImmutableList<Port> 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 <E> ImmutableList<E> copyOf(Collection<? extends E> elements) {
if (elements instanceof ImmutableCollection) {
ImmutableList<E> list = ((ImmutableCollection)elements).asList();
return list.isPartialView() ? asImmutableList(list.toArray()) : list;
} else {
return construct(elements.toArray());
}
}
查看asList方法，发现如果是0个或1个元素，实际上是调用ImmutableList.of()方法。多个元素的话，返回的是一个新的RegularImmutableAsList对象
public ImmutableList<E> 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<E> delegate, Object[] array) {
this(delegate, ImmutableList.asImmutableList(array));
}
static <E> ImmutableList<E> asImmutableList(Object[] elements, int length) {
switch(length) {
case 0:
return of();
case 1:
ImmutableList<E> 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 <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
所以，如果用asList方法，最好用基本类型包装类。
2.返回的集合无法add等操作
asList返回的ArrayList<E> 不是java.util下的，而是Arrays下的内部静态类，继承了AbstractList，确没有重写add等方法，还是会默认用父类的add方法，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) {
if (array==null)
throw new NullPointerException();
a = array;
}
//.................
}
