java中不可修改列表的类型是什么

Question

Unmodifiable list in java can be created as:

List<String> unModifiableStringList = Collections.unmodifiableList(myActualModifiableList);

This is fine, but what is the actual runtime type of the list returned by the above function? How can we access that class? Is it even possible?

UPDATE: Actually I need to know at compile time that an unmodifiable list is being modified, Since I have to deal with a lot of lists, some of which are modifiable and others are not. So it is very cumbersome to keep track?

Answer 1

Actually I need to know at compile time that an unmodifiable list is being modified.

That is not possible.

Or at least, it is not possible without creating a completely different collections interface / class hierarchy. And that's a bad idea because nothing designed to use regular collections would work with it.

I suppose it would be possible to write a static code analyser that could detect this kind of thing ... in some cases ... but that's not strictly "compile time". Besides, I'm not aware of any existing static code analyser that does this "out of the box".

---

I wonder if there was a reason why they did it like this.

Well none of the ways you might do this really work.

Alternative #1:

 public interface UnmodifiableList<T> {
     public T get(int pos);
     ....
 }

 public interface List<T> extends UnmodifiableList<T> {
     public void add(T elem);
     ....
 }

While static typing can prevent us from using an unmodifiable list where a modifiable one is required, the reverse is not true. Every List is also an UnmodifiableList ... and that doesn't really make sense.

Alternative 2:

 public interface List <T> {
     public T get(int pos);
     public void add(T elem);
     ....
 }

 public interface UnmodifiableList<T> {
     // A marker interface
 }

Now static typing can prevent us from using an modifiable list where an umodifiable one is required, but not the reverse. (That suits your requirement ...) Furthermore, a class that implements UnmodifiableList still inherits the add operation, and there's nothing to stop an application from trying to call it.

In short, static type systems cannot adequately handle this kind of restriction.

Answer 2

Have you tried unModifiableStringList.getClass().getName() ?

To me it gives

java.util.Collections$UnmodifiableRandomAccessList

which, as seen from the source code, is a package-access static inner class of Collections .

Answer 3

It is

static class UnmodifiableList<E> extends UnmodifiableCollection<E>
                      implements List<E>

static class UnmodifiableRandomAccessList<E> extends UnmodifiableList<E>
                                      implements RandomAccess

static class UnmodifiableCollection<E> implements Collection<E>, Serializable

It is inner class of Collections , since Collections is non-instantiable and it is inner class with package visibility, you can not access the class, and it is the implementation hiding in OOP.

Answer 4

See: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/Collections.java#Collections.unmodifiableList%28java.util.List%29

It's an inner class in Collections :

static class UnmodifiableList<E> extends UnmodifiableCollection<E>
                                 implements List<E>

Answer 5

Debug shows that the runtime type is Collections.UnmodifiableRandomAccessList , so it's internal class. Code analysis also shows that it might be Collections.UnmodifiableList .

You shouldn't try to access this class, it's meant to be immutable. Try to use common interface instead, in this case = Collection .

Answer 6

Your statement clearly says its still reference of List but it suppress modification of the list.

http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Collections.html#unmodifiableList(java.util.List )

If you share unmodifiable list reference you make sure that nobody changes it and allow read only operations.