Java Collections.unmodifiableList（）时间复杂度

Question

I am wondering what's the time complexity of Collections.unmodifiableList ?

If I want to make an incoming Collection immutable, what's the cheapest way?

Answer 1

I am wondering what's the time complexity of Collections.unmodifiableList ?

Collections.unmodifiableList returns a view of its argument list as opposed to a copy, so it's O(1). This is typically how you'd create an immutable list, but be sure to not change the original mutable list, since those changes will be reflected in the newly created immutable list. This shouldn't be a problem if you keep the original list private. This is the situation I'm talking about:

List<String> modifiableList = new ArrayList<>();
List<String> unmodifiableList = Collections.unmodifiableList(modifiableList);

System.out.println(unmodifiableList);
modifiableList.add("hello");
System.out.println(unmodifiableList);

[]
[hello]

This happens because unmodifiableList is a view (and not a copy) of modifiableList .

Answer 2

Time complexity for which operations?

For all non-modifying operations, it would be in the same O notation as the underlying data structure.

For all modifying operations, it probably would be just a bit faster (early error exiting).

Answer 3

Collections.unmodifiableList is good approach to making Collection<> immutable. As well it returns an unmodifiable wrapper; it does not copy the contents of the input list.

So its not slowing down the process and efficient for large object as well.

Answer 4

Collections.unmodifiableList is cheapest way to immutable.

It just return a wrapper list implementation.

It wont copy the list.

They override the following method like below.

public void add(int index, E element) {
    throw new UnsupportedOperationException();
    }
public E remove(int index) {
    throw new UnsupportedOperationException();
    }

So If any one tries add / delete it will throw exception.

They override the get method like below

public E get(int index) {return list.get(index);}

So it just delegate the actual list to get.

But It has one drawback.

List unmodifiable= Collections.unmodifiableList(list);

unmodifiable.remove(0);

it throws exception.

If you change the original list It will reflect in unmodifiable also.

list.remove(0);

It will reflect the unmodifiable list also.