Discussions
Categories
- 385.5K All Categories
- 5.1K Data
- 2.5K Big Data Appliance
- 2.5K Data Science
- 453.4K Databases
- 223.2K General Database Discussions
- 3.8K Java and JavaScript in the Database
- 47 Multilingual Engine
- 606 MySQL Community Space
- 486 NoSQL Database
- 7.9K Oracle Database Express Edition (XE)
- 3.2K ORDS, SODA & JSON in the Database
- 585 SQLcl
- 4K SQL Developer Data Modeler
- 188K SQL & PL/SQL
- 21.5K SQL Developer
- 46 Data Integration
- 46 GoldenGate
- 298.4K Development
- 4 Application Development
- 20 Developer Projects
- 166 Programming Languages
- 295K Development Tools
- 150 DevOps
- 3.1K QA/Testing
- 646.7K Java
- 37 Java Learning Subscription
- 37.1K Database Connectivity
- 201 Java Community Process
- 108 Java 25
- 22.2K Java APIs
- 138.3K Java Development Tools
- 165.4K Java EE (Java Enterprise Edition)
- 22 Java Essentials
- 176 Java 8 Questions
- 86K Java Programming
- 82 Java Puzzle Ball
- 65.1K New To Java
- 1.7K Training / Learning / Certification
- 13.8K Java HotSpot Virtual Machine
- 94.3K Java SE
- 13.8K Java Security
- 208 Java User Groups
- 25 JavaScript - Nashorn
- Programs
- 667 LiveLabs
- 41 Workshops
- 10.3K Software
- 6.7K Berkeley DB Family
- 3.6K JHeadstart
- 6K Other Languages
- 2.3K Chinese
- 207 Deutsche Oracle Community
- 1.1K Español
- 1.9K Japanese
- 474 Portuguese
How to do Collections.EMPTY_SET in Generics?
In non-Generic code, I sometimes use Collections.EMPTY_SET:
Geoff
public class Test { private Set setWhichCanBeNull; public Test( Set setWhichCanBeNull ) { this.setWhichCanBeNull = setWhichCanBeNull; } public Set getSet() { return ( setWhichCanBeNull == null ) ? Collections.EMPTY_SET : setWhichCanBeNull; } }If I write this using Generics, Collections.EMPTY_SET does not work, since it does not know what type I am interested in:
public class Test<E> { private Set<E> setWhichCanBeNull; public Test( Set<E> setWhichCanBeNull ) { this.setWhichCanBeNull = setWhichCanBeNull; } public Set<E> getSet() { return ( setWhichCanBeNull == null ) ? Collections.EMPTY_SET : setWhichCanBeNull; } }Is there any way to specify something like this:
Collections<E>.EMPTY_SETor am I stuck with having to write:
public Set<E> getSet() { return ( setWhichCanBeNull == null ) ? new HashSet<E>() : setWhichCanBeNull; }Thanks.
Geoff
Comments
-
I wish I knew. I sent this same question to the JSR 14 expert group during the public review process. Apparently the question was either too trivial or too much of a stumper to warrant a response.
Another question I asked, which seems even more problematic, was the question of how addAll() will work. In the public review collections API, it was declared as:interface Collection<E> { void addAll(Collection<E> stuff); }
That prevents the following from working:List<String> x; List<Object> y; ... y.addAll(x);
Yikes!! That alone would be reason to vote down the JSR in my mind. Really, there should be a way to declare addAll() something like this:interface Collection<E> { void addAll(Collection<T extends E> stuff); }
Does anyone know if this problem was/will be fixed in the final draft for JSR 14? -
This won't work?
interface Collection<E> { <T extends E> void addAll(Collection<T> stuff); }
-
It works with the actual prototype compiler (v 1.2).
-
The short answer is: you can't do that. However, you
can make a method that returns the empty set. -
schapel wrote:This won't work?joerg.wassmer wrote:
interface Collection<E> {
<T extends E> void addAll(Collection<T> stuff);
}It works with the actual prototype compiler (v 1.2).Great! I just downloaded the new prototype, and it does indeed work. This was broken in the version I downloaded about 8 months ago, and I'm very glad to see that it was fixed.
So here's a stumper. Suppose I have the following:public interface Event { } public class EventSuper implements Event { } public class EventSub extends EventSuper { } public class EventListener<E extends Event> { public void handleEvent(E event) { System.out.println("got event: " + event); } } public class EventBroadcaster<E extends Event> { public void addListener(EventListener<E> listener) { listeners.add(listener); } public void removeListener(EventListener<E> listener) { listeners.remove(listener); } public void broadcast(E event) { for(Iterator<EventListener<E>> i = listeners.iterator(); i.hasNext(); ) i.next().handleEvent(event); } private List<EventListener<E>> listeners = new LinkedList<EventListener<E>>(); }
Really, I ought to be able to do this:EventBroadcaster<EventSub> b = new EventBroadcaster<EventSub>(); EventListener<EventSuper> l = new EventListener<EventSuper>(); b.addListener(l); b.broadcast(new EventSub());
How do I finesse the EventBroadcaster and EventListener to allow that?
This discussion has been closed.