# How to Get the Difference Between Two Sets in Java

How can we obtain the difference (or symmetric difference) between two sets in Java?

The **difference** of two sets refers to all elements in one set but not the other.

The **symmetric difference** of two sets refers to all elements in either set but *not* in both.

Suppose we have two instances of a `HashSet`

, both populated with objects of some class `T`

.

```
Set<T> set1 = new HashSet<>();
Set<T> set2 = new HashSet<>();
```

## 1. Using Guava

If we’re using Guava, we can use `Sets.difference()`

to obtain all elements in `set1`

but not in `set2`

.

```
SetView<T> diff = Sets.difference(set1, set2);
```

We can also obtain the *symmetric difference* of the two sets using `Sets.symmetricDifference()`

. This will return all elements in either `set1`

or `set2`

but *not* in both.

```
SetView<T> symDiff = Sets.symmetricDifference(set1, set2);
```

In both solutions above, `set1`

and `set2`

are not modified.

The resulting `SetView`

is a `Set`

that we can make immutable (using `.immutableCopy()`

) or copy into another set (using `.copyInto(set3)`

).

Note that the result of these two functions will be undefined if

`set1`

and`set2`

are sets based on different equivalence relations (i.e.`HashSet`

,`TreeSet`

,`IdentityHashMap.keySet()`

).

## 2. Using Apache Commons Collection

If we have the Apache Commons Collections available, we can use `SetUtils.difference()`

.

This will return all elements in `set1`

but not in `set2`

.

```
SetUtils.difference(set1, set2);
```

If we want the symmetric difference (all elements in either `set1`

or `set2`

but not both), then we can use `CollectionUtils.disjunction()`

.

```
CollectionUtils.disjunction(set1, set2);
```

## 3. Using `Set.removeAll()`

We can also use `Set.removeAll()`

to get the intersection of two sets.

After running the code below, `set1`

will contain all elements *originally* in `set1`

but not in `set2`

.

```
set1.removeAll(set2);
```

If we do not want to mutate either of the sets, we can create a copy.

```
Set<T> diff = new HashSet<>(set1)
diff.removeAll(set2);
```

To obtain the symmetric difference, we can do the following:

```
Set<T> symDiff = new HashSet<T>(set1);
symDiff.addAll(set2);
Set<T> temp = new HashSet<T>(set1);
temp.retainAll(set2);
symDiff.removeAll(temp);
```

## 4. Using `Set.removeIf()`

We can use `Set.removeIf()`

if we’re running Java 8 or above.

Similarly, if we can mutate the set, we can call `Set.removeIf()`

directly on the set.

```
set1.removeIf(set2::contains);
```

Otherwise, we can first create a copy, then run the function.

```
Set<T> diff = new HashSet<T>(set1);
diff.removeIf(set2::contains);
```

Obtaining the symmetric difference looks the same as well:

```
Set<T> symDiff = new HashSet<T>(set1);
symDiff.addAll(set2);
Set<T> temp = new HashSet<T>(set1);
temp.retainAll(set2);
symDiff.removeIf(temp::contains);
```