boolean[] vs. BitSet: Which is more efficient?

jmh/pom.xml

@@ -26,6 +26,11 @@
             <artifactId>jmh-generator-annprocess</artifactId>
             <version>${openjdk.jmh.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.openjdk.jol</groupId>
+            <artifactId>jol-core</artifactId>
+            <version>${jol-core.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -42,12 +47,39 @@
                     </archive>
                 </configuration>
             </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <version>${maven-assembly-plugin.version}</version>
+                <configuration>
+                    <descriptorRefs>
+                        <descriptorRef>jar-with-dependencies</descriptorRef>
+                    </descriptorRefs>
+                    <archive>
+                        <manifest>
+                            <mainClass>com.baeldung.BenchmarkRunner</mainClass>
+                        </manifest>
+                    </archive>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>make-assembly</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 
     <properties>
         <openjdk.jmh.version>1.19</openjdk.jmh.version>
         <maven-jar-plugin.version>3.0.2</maven-jar-plugin.version>
+        <jol-core.version>0.10</jol-core.version>
+        <maven-assembly-plugin.version>3.2.0</maven-assembly-plugin.version>
     </properties>
 
 </project>

jmh/src/main/java/com/baeldung/bitset/Plotter.java

@@ -0,0 +1,36 @@
+package com.baeldung.bitset;
+
+import org.openjdk.jol.info.ClassLayout;
+import org.openjdk.jol.info.GraphLayout;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.BitSet;
+
+public class Plotter {
+
+    public static void main(String[] args) throws IOException {
+        Path path = Paths.get("footprint.csv");
+        try (BufferedWriter stream = Files.newBufferedWriter(path, StandardOpenOption.CREATE)) {
+            stream.write("bits,bool,bitset\n");
+
+            for (int i = 0; i <= 10_000_000; i += 500) {
+                System.out.println("Number of bits => " + i);
+
+                boolean[] ba = new boolean[i];
+                BitSet bitSet = new BitSet(i);
+
+                long baSize = ClassLayout.parseInstance(ba).instanceSize();
+                long bitSetSize = GraphLayout.parseInstance(bitSet).totalSize();
+
+                stream.write((i + "," + baSize + "," + bitSetSize + "\n"));
+
+                if (i % 10_000 == 0) stream.flush();
+            }
+        }
+    }
+}

jmh/src/main/java/com/baeldung/bitset/Sizing.java

@@ -0,0 +1,17 @@
+package com.baeldung.bitset;
+
+import org.openjdk.jol.info.ClassLayout;
+import org.openjdk.jol.info.GraphLayout;
+
+import java.util.BitSet;
+
+public class Sizing {
+
+    public static void main(String[] args) {
+        boolean[] ba = new boolean[10_000];
+        System.out.println(ClassLayout.parseInstance(ba).toPrintable());
+
+        BitSet bitSet = new BitSet(10_000);
+        System.out.println(GraphLayout.parseInstance(bitSet).toPrintable());
+    }
+}

jmh/src/main/java/com/baeldung/bitset/VectorOfBitsBenchmark.java

@@ -0,0 +1,75 @@
+package com.baeldung.bitset;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+
+import java.util.BitSet;
+import java.util.concurrent.ThreadLocalRandom;
+
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.Throughput)
+public class VectorOfBitsBenchmark {
+
+    private boolean[] array;
+    private BitSet bitSet;
+
+    @Param({"100", "1000", "5000", "50000", "100000", "1000000", "2000000", "3000000",
+             "5000000", "7000000", "10000000", "20000000", "30000000", "50000000", "70000000", "1000000000"})
+    public int size;
+
+    @Setup(Level.Trial)
+    public void setUp() {
+        array = new boolean[size];
+        for (int i = 0; i < array.length; i++) {
+            array[i] = ThreadLocalRandom.current().nextBoolean();
+        }
+
+        bitSet = new BitSet(size);
+        for (int i = 0; i < size; i++) {
+            bitSet.set(i, ThreadLocalRandom.current().nextBoolean());
+        }
+    }
+
+    @Benchmark
+    public boolean getBoolArray() {
+        return array[ThreadLocalRandom.current().nextInt(size)];
+    }
+
+    @Benchmark
+    public boolean getBitSet() {
+        return bitSet.get(ThreadLocalRandom.current().nextInt(size));
+    }
+
+    @Benchmark
+    public void setBoolArray() {
+        int index = ThreadLocalRandom.current().nextInt(size);
+        array[index] = true;
+    }
+
+    @Benchmark
+    public void setBitSet() {
+        int index = ThreadLocalRandom.current().nextInt(size);
+        bitSet.set(index);
+    }
+
+    @Benchmark
+    public int cardinalityBoolArray() {
+        int sum = 0;
+        for (boolean b : array) {
+            if (b) sum++;
+        }
+
+        return sum;
+    }
+
+    @Benchmark
+    public int cardinalityBitSet() {
+        return bitSet.cardinality();
+    }
+}