Classical set operations for java.util.Collection

Question

Is there any built-in functionality for classical set operations on the java.util.Collection class? My specific implementation would be for ArrayList, but this sounds like something that should apply for all subclasses of Collection. I'm looking for something like:

ArrayList<Integer> setA ...
ArrayList<Integer> setB ...
ArrayList<Integer> setAintersectionB = setA.intersection(setB);
ArrayList<Integer> setAminusB = setA.subtract(setB);

After some searching, I was only able to find home-grown solutions. Also, I realize I may be confusing the idea of a "Set" with the idea of a "Collection", not allowing and allowing duplicates respectively. Perhaps this is really just functionality for the Set interface?

In the event that nobody knows of any built-in functionality, perhaps we could use this as a repository for standard practice Java set operation code? I imagine this wheel has been reinvented numerous times.

Answer 1

Intersection is done with Collection.retainAll ; subtraction with Collection.removeAll ; union with Collection.addAll . In each case, as Set will act like a set and a List will act like a list.

As mutable objects, they operate in place. You'll need to explicitly copy if you want to retain the original mutable object unmutated.

Answer 2

I would recommend Google Guava . The Sets class seems to have exactly what you are looking for. It has a intersection method and a difference method.

This presentation is probably something you want to watch if you're interested. It refers to Google Collections, which was Guava's original name.

Answer 3

Are you looking for java.util.Set interface (and its implementations HashSet and TreeSet (sorted))?
The interface defines removeAll(Collection c) which looks like substract(), and retainAll(Collection c) which looks like intersection.

Answer 4

For mutable operations see accepted answer.

For an imutable variant you can do this with java 8

subtraction

set1
  .stream()
  .filter(item-> !set2.contains(item))
  .collect(Collectors.toSet())

intersection

set1
  .stream()
  .filter(item-> set2.contains(item))
  .collect(Collectors.toSet())