BAEL-5912 Introduction to RoaringBitmap (#13326)

core-java-modules/core-java-collections-5/src/main/java/com/baeldung/roaringbitmap/BitSetsBenchmark.java

@@ -0,0 +1,82 @@
+package com.baeldung.roaringbitmap;
+
+import java.util.BitSet;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.roaringbitmap.RoaringBitmap;
+
+@State(Scope.Thread)
+public class BitSetsBenchmark {
+    private RoaringBitmap rb1;
+    private BitSet bs1;
+    private RoaringBitmap rb2;
+    private BitSet bs2;
+    private final static int SIZE = 10_000_000;
+
+    @Setup
+    public void setup() {
+        rb1 = new RoaringBitmap();
+        bs1 = new BitSet(SIZE);
+        rb2 = new RoaringBitmap();
+        bs2 = new BitSet(SIZE);
+        for (int i = 0; i < SIZE / 2; i++) {
+            rb1.add(i);
+            bs1.set(i);
+        }
+        for (int i = SIZE / 2; i < SIZE; i++) {
+            rb2.add(i);
+            bs2.set(i);
+        }
+    }
+
+    @Benchmark
+    public RoaringBitmap roaringBitmapUnion() {
+        return RoaringBitmap.or(rb1, rb2);
+    }
+
+    @Benchmark
+    public BitSet bitSetUnion() {
+        BitSet result = (BitSet) bs1.clone();
+        result.or(bs2);
+        return result;
+    }
+
+    @Benchmark
+    public RoaringBitmap roaringBitmapIntersection() {
+        return RoaringBitmap.and(rb1, rb2);
+    }
+
+    @Benchmark
+    public BitSet bitSetIntersection() {
+        BitSet result = (BitSet) bs1.clone();
+        result.and(bs2);
+        return result;
+    }
+
+    @Benchmark
+    public RoaringBitmap roaringBitmapDifference() {
+        return RoaringBitmap.andNot(rb1, rb2);
+    }
+
+    @Benchmark
+    public BitSet bitSetDifference() {
+        BitSet result = (BitSet) bs1.clone();
+        result.andNot(bs2);
+        return result;
+    }
+
+    @Benchmark
+    public RoaringBitmap roaringBitmapXOR() {
+        return RoaringBitmap.xor(rb1, rb2);
+    }
+
+    @Benchmark
+    public BitSet bitSetXOR() {
+        BitSet result = (BitSet) bs1.clone();
+        result.xor(bs2);
+        return result;
+    }
+}

core-java-modules/core-java-collections-5/src/main/java/com/baeldung/roaringbitmap/BitSetsBenchmarkRunner.java

@@ -0,0 +1,9 @@
+package com.baeldung.roaringbitmap;
+
+import java.io.IOException;
+
+public class BitSetsBenchmarkRunner {
+    public static void main(String... args) throws IOException {
+        org.openjdk.jmh.Main.main(args);
+    }
+}

core-java-modules/core-java-collections-5/src/test/java/com/baeldung/roaringbitmap/RoaringBitmapBenchmarkUnitTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.roaringbitmap;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import org.roaringbitmap.RoaringBitmap;
+
+class RoaringBitmapBenchmarkUnitTest {
+    @Test
+    public void givenTwoRoaringBitmap_whenUsingOr_thenWillGetSetsUnion() {
+        RoaringBitmap expected = RoaringBitmap.bitmapOf(1, 2, 3, 4, 5, 6, 7, 8);
+        RoaringBitmap A = RoaringBitmap.bitmapOf(1, 2, 3, 4, 5);
+        RoaringBitmap B = RoaringBitmap.bitmapOf(4, 5, 6, 7, 8);
+        RoaringBitmap union = RoaringBitmap.or(A, B);
+        assertEquals(expected, union);
+    }
+
+    @Test
+    public void givenTwoRoaringBitmap_whenUsingAnd_thenWillGetSetsIntersection() {
+        RoaringBitmap expected = RoaringBitmap.bitmapOf(4, 5);
+        RoaringBitmap A = RoaringBitmap.bitmapOfRange(1, 6);
+        RoaringBitmap B = RoaringBitmap.bitmapOf(4, 5, 6, 7, 8);
+        RoaringBitmap intersection = RoaringBitmap.and(A, B);
+        assertEquals(expected, intersection);
+    }
+
+    @Test
+    public void givenTwoRoaringBitmap_whenUsingAndNot_thenWillGetSetsDifference() {
+        RoaringBitmap expected = RoaringBitmap.bitmapOf(1, 2, 3);
+        RoaringBitmap A = new RoaringBitmap();
+        A.add(1L, 6L);
+        RoaringBitmap B = RoaringBitmap.bitmapOf(4, 5, 6, 7, 8);
+        RoaringBitmap difference = RoaringBitmap.andNot(A, B);
+        assertEquals(expected, difference);
+    }
+
+    @Test
+    public void givenTwoRoaringBitmap_whenUsingXOR_thenWillGetSetsSymmetricDifference() {
+        RoaringBitmap expected = RoaringBitmap.bitmapOf(1, 2, 3, 6, 7, 8);
+        RoaringBitmap A = RoaringBitmap.bitmapOfRange(1, 6);
+        RoaringBitmap B = RoaringBitmap.bitmapOfRange(4, 9);
+        RoaringBitmap xor = RoaringBitmap.xor(A, B);
+        assertEquals(expected, xor);
+    }
+}