# Primitive Set Operations in Eclipse Collections — Part 2

In 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 A — 1, 2, 3.

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 A — 1, 2.

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 A — 1, 3.

Set B — 2, 4.

Cartesian Product —

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

# Cartesian Product — Code Implementation

🛈 Eclipse Collections has a static unility 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.