Cloning and subtracting sets - does this work?

Question

private HashMap<DataObject, HashSet> AllDataObjects;

...

/** Returns all DataObject elements that are NOT in the specified set. */
private DataObject[] invert( HashSet<DataObject> set )
{
    HashSet<DataObject> keys = (HashSet) AllDataObjects.keySet();
    keys = (HashSet) keys.clone();

    keys.removeAll( set );

    return (DataObject[]) keys.toArray();
}

Note that I don't want to alter AllDataObjects through this process. I casted the set of AllDataObjects' keys (which are the DataObjects I want the set parameter to subtract from) into a HashSet to use clone, which supposedly returns a shallow copy that I can then remove set from without affecting AllDataObjects.

Does this look right to you?

Answer 1

Create a new set and give the one to be cloned as an argument. This avoids casting and so you don't lose generics.

private DataObject[] invert( Set<DataObject> set ){
    Set<DataObject> keys = new HashSet<DataObject>(AllDataObjects.keySet());
    keys.removeAll( set );
    return keys.toArray(new DataObject[]{});
}

It's also worth noting that you should use Set rather than HashSet for the parameter so as to not overly burden your clients.

Answer 2

Knowing that these sets were populated by a relational query, I would suggest that you at least trade off writing a better SQL query to get what you want rather than doing it in memory. There are several reasons why. First, most relational databases are optimized to do this more efficiently than your code will. Second, you're letting the server where the relational database is running do more of the work that it was intended for. Third, if the size of the sets become large you'll be unnecessarily burdening the middle tier by having to bring back the results, allocate memory for them, and then throw away the unwanted results.

Answer 3

I think this link has a better way to write that method if you must:

Java: Is there an easy, quick way to AND, OR, or XOR together sets?