Java unmodifiable array

final Integer[] arr={1,2,3};
arr[0]=3;
System.out.println(Arrays.toString(arr));

I tried the above code to see whether a final array's variables can be reassigned[ans:it can be].I understand that by a final Integer[] array it means we ca开发者_高级运维nnot assign another instance of Integer[] apart from the one we have assigned initially.I would like to know if whether it is possible to make the array variables also unmodifiable.

---

This isn't possible as far as I know.

There is however a method Collections.unmodifiableList(..) which creates an unmodifiable view of e.g. a List<Integer>.

If you want to guarantee that not even the creator of the unmodifiable view list will be able to modify the underlying (modifiable) list, have a look at Guava's ImmutableList.

---

No. The contents of an array can be changed. You can't prevent that.

Collections has various methods for creating unmodifiable collections, but arrays aren't provided for.

---

The final keyword only prevents changing the arr reference, i.e. you can't do:

final int[] arr={1,2,3}; 
arr = new int[5]; 

If the object arr is referring to is mutable object (like arrays), nothing prevents you from modifying it.

The only solution is to use immutable objects.

---

Another way is to use this function:

Arrays.copyOf(arr, arr.length);

---

The keyword 'final' applies to only the references (pointer to the memory location of the object in the heap). You can't change the memory address (location) of the object. Its upto your object how it internally handles the immutability.

Added, although int is a primitive data type int[] should be treated as a object.

You can't do this

final int a = 5
a = 6

You can do this:

final int[] a = new int[]{2,3,4};
  a[0] = 6;

You can't do this:

final int[] a = new int[]{2,3,4};
 a = new int[]{1,2,3}

---

To anybody else reading this old question, keep in mind there is also Google Guava's immutable collections. ImmutableList has much stronger performance than Collections.unmodifiableList(), and is arguably safer as it truly is immutable,and not backed by a mutable collection.

---

I'd go with List.of(array), as available from Java 9 on, which creates a copy of the source array internally and an immutable List from that. Note though, there there're no null values allowed in this implementation.

If this is a requirement, Arrays.copyOf([T]source, int length) can be used, if no real immutability is needed, but only the source array mustn't be modified.

Otherwise, if immutability of the target Collection is required, Java's immutable Collection API or Guava might be your best shot e. g. Collections.immutableXX() or ImmutableList.of().

If additional dependencies are not desired, one of the following approaches should work, depending on, whether further pre-processing is needed, before making the result immutable:

final T[] objects = (T[])new Object[] { null };
final T obj = (T)new Object();

final BinaryOperator<ArrayList<T>> listCombiner = (a,b) -> { a.addAll(b); return a; };
final Collector<T, ArrayList<T>, List<T>> collector = Collector.of(
  ArrayList<T>::new, List::add, listCombiner, Collections::unmodifiableList
);

final List<T> list = Arrays.stream(objects).collect(collector);

or simply

final List<T> list = Collections.unmodifiableList(Arrays.asList(objects ));

Edit: As already outlined, creating an immutable array in itself is not possible in Java.