# Primitive Set Operations in Eclipse Collections — Part 2

Continuing from Part 1, in the Eclipse Collections 11.0 release, we will have the following Set operations `union`

, `intersect`

, `difference`

, `symmetricDifference`

, `isSubsetOf`

, `isProperSubsetOf`

, `cartesianProduct`

on primitive collections.

These APIs are already available on Sets on the object side, but my goal was to implement these methods for Sets supporting primitive types namely `IntSet`

, `LongSet`

, `ShortSet`

, `DoubleSet`

, `FloatSet`

, `CharSet`

, `BooleanSet`

, `ByteSet`

. Additionally, the above operations will be available in both mutable and immutable interfaces.

I covered the first three operations (`union`

, `intersect`

and `difference`

) in this blog. I will talk about the remaining operations here.

### Symmetric Difference — What does this operation do?

Method signature: `setA.symmetricDifference(setB)`

This operation returns a set that contains elements that are in either one of the two sets but not **both**. In other words, (Set A — Set B) U (Set B — Set A).

Set B — 2, 3, 4.

A — B = 1.

B — A= 4.

Symmetric Difference — 1, 4.

### Symmetric Difference — Code Implementation

🛈 Eclipse Collections has an existing API that allows us to `reject`

that returns all the elements that evaluate false for the given`Predicate`

and results are added to a target collection. Predicate here is `this::contains`

and target collection is the set returned from `this.difference(set)`

.

At this point of implementing `symmetricDifference`

, we already had an API that can compute `difference`

of Set A and Set B.

default MutableIntSet symmetricDifference(IntSet set) { return set.reject(this::contains, this.difference(set)); }

### Symmetric Difference — Usage

@Test public void symmetricDifference() { MutableIntSet setA = IntSets.mutable.with(1, 2, 3); MutableIntSet setB = IntSets.mutable.with(2, 3, 4); MutableIntSet expected = IntSets.mutable.with(1, 4); MutableIntSet actual = setA.symmetricDifference(setB); Assert.assertEquals(expected, actual); }

Test cases covering various scenarios can be found here.

### Is Subset of — What does this operation do?

Method signature: `setA.isSubsetOf(setB)`

This operation returns true if all elements from Set A are present in Set B.

Set B — 1, 2, 3.

Is Set A a subset of Set B — true.

### Is Subset Of — Code Implementation

🛈 Eclipse Collections has an existing API called `containsAll`

that evaluates to true if all the values in `this`

are present in `set`

.

default boolean isSubsetOf(IntSet set) { return this.size() <= set.size() && set.containsAll(this); }

### Is Subset of — Usage

@Test public void isSubsetOf() { MutableIntSet setA = IntSets.mutable.with(1, 2); MutableIntSet setB = IntSets.mutable.with(1, 2, 3); Assert.assertTrue(setA.isSubsetOf(setB)); MutableIntSet setC = IntSets.mutable.with(1, 2, 3); MutableIntSet setD = IntSets.mutable.with(1, 2, 3); Assert.assertTrue(setC.isSubsetOf(setD)); }

Test cases covering various scenarios can be found here.

### Is Proper Subset of — What does this operation do?

Method signature: `setA.isProperSubsetOf(setB)`

This operation returns true if all elements of Set A are present in Set B but the two sets are not equal i.e. there is at least one element in Set B that is not present in Set A.

### Is Proper Subset of —Code Implementation

default boolean isProperSubsetOf(IntSet set) { return this.size() < set.size() && set.containsAll(this); }

### Is Proper Subset of — Usage

@Test public void isProperSubsetOf() { MutableIntSet setA = IntSets.mutable.with(1, 2); MutableIntSet setB = IntSets.mutable.with(1, 2, 3); Assert.assertTrue(setA.isProperSubsetOf(setB)); MutableIntSet setC = IntSets.mutable.with(1, 2, 3); MutableIntSet setD = IntSets.mutable.with(1, 2, 3); Assert.assertFalse(setC.isProperSubsetOf(setD)); }

Test cases covering various scenarios can be found here.

### Cartesian Product — What does this operation do?

Method Signature: `setA.cartesianProduct(setB)`

Cartesian Product of Set A and Set B is the set of all possible ordered pairs where the first element of the pair is from Set A and the second element from Set B.

Set B — 2, 4.

Cartesian Product —

{(1, 2), (1, 4), (3, 2). (3, 4)}.

### Cartesian Product — Code Implementation

🛈 Eclipse Collections has a static utility class called `IntSets`

and equivalent classes for other primitive set collections.

@Override public LazyIterable<IntIntPair> cartesianProduct(IntSet set) { return IntSets.cartesianProduct(this, set); }

Below code is the underlying `cartesianProduct`

implementation.

public static <A, B, C> LazyIterable<C> cartesianProduct(IntSet set1, IntSet set2, IntIntToObjectFunction<C> function) { return set1.asLazy() .flatCollect(first -> set2.asLazy() .collect(second -> function.value(first, second))); }

### Cartesian Product — Usage

@Test public void cartesianProduct() { MutableIntSet setA = IntSets.mutable.with(1, 3); MutableIntSet setB = IntSets.mutable.with(2, 4); MutableSet<IntIntPair> expected = Sets.mutable.with( PrimitiveTuples.pair(1, 2), PrimitiveTuples.pair(1, 4), PrimitiveTuples.pair(3, 2), PrimitiveTuples.pair(3, 4)); Assert.assertEquals(expected, setA.cartesianProduct(setB).toSet()); }

Test cases covering various scenarios can be found here.

*I am a committer for the **Eclipse Collections** OSS project at Eclipse Foundation. **Eclipse Collections** is open for contributions *and if you like our library, let us know by starring our GitHub repository.

## Comments (0)