Collections.unmodifiableList

Collections.unmodifiableList的用法场景实际上就是只读，通过传入一个集合，对该集合进行包装，然后在List接口的方法实现里对add,addAll,remove,set方法作了抛异常处理，以至于如果对该包装对象作任何修改操作都会遭到拒绝。源码如下：

private static class UnmodifiableList<E> extends UnmodifiableCollection<E>
implements List<E> {
private static final long serialVersionUID = -283967356065247728L;

final List<E> list;

UnmodifiableList(List<E> l) {
super(l);
list = l;
}

@Override public void add(int location, E object) {
throw new UnsupportedOperationException();
}

@Override public boolean addAll(int location, Collection<? extends E> collection) {
throw new UnsupportedOperationException();
}

@Override public boolean equals(Object object) {
return list.equals(object);
}

@Override public E get(int location) {
return list.get(location);
}

@Override public int hashCode() {
return list.hashCode();
}

@Override public int indexOf(Object object) {
return list.indexOf(object);
}

@Override public int lastIndexOf(Object object) {
return list.lastIndexOf(object);
}

@Override public ListIterator<E> listIterator() {
return listIterator(0);
}

@Override public ListIterator<E> listIterator(final int location) {
return new ListIterator<E>() {
ListIterator<E> iterator = list.listIterator(location);

@Override public void add(E object) {
throw new UnsupportedOperationException();
}

@Override public boolean hasNext() {
return iterator.hasNext();
}

@Override public boolean hasPrevious() {
return iterator.hasPrevious();
}

@Override public E next() {
return iterator.next();
}

@Override public int nextIndex() {
return iterator.nextIndex();
}

@Override public E previous() {
return iterator.previous();
}

@Override public int previousIndex() {
return iterator.previousIndex();
}

@Override public void remove() {
throw new UnsupportedOperationException();
}

@Override public void set(E object) {
throw new UnsupportedOperationException();
}
};
}

@Override public E remove(int location) {
throw new UnsupportedOperationException();
}

@Override public E set(int location, E object) {
throw new UnsupportedOperationException();
}

@Override public List<E> subList(int start, int end) {
return new UnmodifiableList<E>(list.subList(start, end));
}

/**
* Resolves UnmodifiableList instances to UnmodifiableRandomAccessList
* instances if the underlying list is a Random Access list.
* <p>
* This is necessary since UnmodifiableRandomAccessList instances are
* replaced with UnmodifiableList instances during serialization for
* compliance with JREs before 1.4.
* <p>
*
* @return an UnmodifiableList instance if the underlying list
*         implements RandomAccess interface, or this same object if
*         not.
*
* @see UnmodifiableRandomAccessList#writeReplace()
*/
private Object readResolve() {
if (list instanceof RandomAccess) {
return new UnmodifiableRandomAccessList<E>(list);
}
return this;
}
}

类似的还有其他各种类型的集合都有对应的方法。实际使用场景，比如说一个类里面有一个集合，你不希望这个集合被外部类进行修改而只能读取，那么只需要写一个get方法，在该方法内返回的是Collections.unmodifiableList(集合)就行了。这种场景有时在adapter里可以见到，你不希望adapter里的data集合的引用被外部类拿去随便作修改，只希望外部调用自己的add或remove方法，这时就可以这样写：

final class Adapter extends BaseAdapter {

List<String> list = Collections.emptyList();

public Adapter(List<String> l) {
list.addAll(l);
}

public void addItem(String s) {
list.add(s);
}

public void removeItem(int position) {
list.remove(position);
}

public List<String> getItems() {
return Collections.unmodifiableList(list);
}

@Override public int getCount() {
return 0;
}

@Override public Object getItem(int position) {
return null;
}

@Override public long getItemId(int position) {
return 0;
}

@Override public View getView(int position, View convertView, ViewGroup parent) {
return null;
}
}