Hey there!
I am new here so first i want to introduce myself. My name is Michael
and i live in germany. For a job i am a java developer with 10 years of
java EE experience. At work my passion is to create long-living core
tools for our projects.
But now for the reason i joined openjdk and this group in particular:
immutable collections.
During development i sometimes stumble upon the fact that there is no
simple way build an immutable object that exposes a read-only
collection, and all this in a compile-time safe manner. To explain it
with code, i want to have something like this:
class Example {
private final Collection<String> values;
public Example(String... args) { this.values = Arrays.asList(args); }
public Collection<String> getValues() { return values; }
}
class Test {
public void test() {
Collection<String> v = new Example("a","b","c").getValues();
v.clear(); // <-- compile time error
}
}
The current approach to this is using either
Collections.unmodifiableXYZ(...), which may lead to runtime exceptions.
Or we use Stream as return object, but there is no simple way to pass
that around and use it multiple times. I don't see Supplier<Stream> as a
solution to this: determining the size of the collection would need to
traverse the whole stream, even if the underlying collection is an
arraylist... not good.
My approach to this would be to split up the Collection-Interface into a
read-only and a mutating part.
But before i present you my somewhat complete solution, i asked myself
if you already discussed something like that. So i dived into the bug
database and found 3 somewhat similar tickets:
1. https://bugs.openjdk.java.net/browse/JDK-6432147
The author wanted to introduce annotations to mark objects as
immutable and on basis of this raise compile exceptions. This would need
a load of annotations throughout the code and additional rules to check
by the compiler. The ticket was closed as a duplicate to [2]
2. https://bugs.openjdk.java.net/browse/JDK-4211070
The author wanted to introduce a new keyword 'const' to be used
just like the annotation in [1]. Same problem: massive spray of the new
keyword throughout the code and the need for a change in the compiler
and even in the language.
3. https://bugs.openjdk.java.net/browse/JDK-5099784
This is as old as JDK1.4.2 (2004) and proposes the same way i want
to go: split the Collection-interface into a new parent-interface that
contains all non-modifying methods and the Collection-interface itself
that then only contains modifying methods. A user of the
Collection-interface would see the same API as before, a user of the new
parent-interface would only see read-only methods.
The original author of [3] is inactive by now, the ticket itself was not
discussed and is still unresolved open.
I would happily try to implement this approach, but first i want to know
if this is the way to go and what your thoughts are about this.
Hope this is not too much text for a Call for Discussion,
Michael
