I'm trying to make code that follows the functional programming paradigm, which follows immutability very religiously, but the only way I know how to make my array even close to being immutable is by using
List<Integer> items = Collections.unmodifiableList(Arrays.asList(0,1,2,3));
I am unsure whether this makes the array immutable or just unmodifiable. If the command above does not make the array immutable what would?
You can't mutate the underlying array (or the list returned by Arrays.asList) except by reflection. However, arrays aren't really relevant here; don't confuse arrays and lists!
Since Java 9, List.of(0, 1, 2, 3) achieves the same.
To do operations which produce new collections, you'll have to go through streams. You may also want to consider third-party libraries, e.g. Guava (this link is to their immutable collections page). Or even better PCollections, which provides only immutable collections and more functional implementations of them than Guava does.
concat, filter or map? You can get them in Java standard library through streams, but not with an immutable collection as output as OP wants.
Arrays.asList(0,1,2,3), you can't mutate the underlying array”.The problem with using Collections.unmodifiableList is that you're not really creating a read-only view on mutable collection, not real immutable collection. It might seem like it's not a big deal, but in reality, the mutable collection acting as immutable won't be very efficient and performant. For example, appending the new element to the list would require copying the whole list.
I would suggest you check out Vavr. It has its own implementation of functional, immutable linked list, which allows you to do appends on constant time (which doesn't require copying whole list, because common elements are shared). For example:
var l1 = List.of(1, 2, 3); //List(1, 2, 3)
var l2 = l1.append(4); //List(1, 2, 3, 4)
In this example both list would share 1,2,3.
You can also convert from and to Java List easily:
java.util.List<String> javaList = Arrays.asList("Java", "Haskell", "Scala");
List<String> vavrList = List.ofAll(javaList);
List<String> vavrStringList = List.of("JAVA", "Javascript", "Scala");
java.util.List<String> javaStringList = vavrStringList.toJavaList();
Vavr list.LinkedList pays the same price. On the other hand, String always has been immutable, but in the past, it had cheap substring operations, but nowadays it hasn’t, to avoid paying the price for all other operations. It’s a common trade off, irrespective of mutable vs immutable.
Arrays.asList.Lists"List. The inlined syntax, whether you useArrays.asList(0,1,2,3)orArrays.asList(new Integer[] {0,1,2,3})ensures that no other reference to the array exists. Since that’s the right approach, I wouldn’t presume that the OP didn’t understand this. That’s not recognizable from the question.