Make BloomFilter.bitSize() public

android/guava-tests/test/com/google/common/hash/BloomFilterTest.java

@@ -353,6 +353,47 @@ public void testBitSize() {
     }
   }
 
+  /**
+   * Tests that bitSize() can be used to predict the serialization size produced by writeTo().
+   *
+   * <p>The serialization format consists of a 6-byte header (1 byte strategy, 1 byte hash
+   * functions, 4 bytes array length) followed by the bit array data (bitSize / 8 bytes).
+   */
+  public void testBitSizeMatchesSerializationSize() throws Exception {
+    int[] expectedInsertionValues = {1, 10, 100, 1000, 10000};
+    double[] fppValues = {0.01, 0.03, 0.1};
+
+    for (int expectedInsertions : expectedInsertionValues) {
+      for (double fpp : fppValues) {
+        BloomFilter<String> bf =
+            BloomFilter.create(Funnels.unencodedCharsFunnel(), expectedInsertions, fpp);
+
+        // Add some elements
+        for (int i = 0; i < expectedInsertions / 2; i++) {
+          bf.put("element" + i);
+        }
+
+        // Calculate expected size based on bitSize()
+        // Header: 1 byte (strategy) + 1 byte (hash functions) + 4 bytes (array length) = 6 bytes
+        // Data: bitSize / 8 bytes
+        long predictedSize = bf.bitSize() / 8 + 6;
+
+        // Serialize and measure actual size
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        bf.writeTo(out);
+        int actualSize = out.size();
+
+        assertEquals(
+            "Serialization size mismatch for expectedInsertions="
+                + expectedInsertions
+                + " fpp="
+                + fpp,
+            predictedSize,
+            actualSize);
+      }
+    }
+  }
+
   public void testApproximateElementCount() {
     int numInsertions = 1000;
     BloomFilter<Integer> bf = BloomFilter.create(Funnels.integerFunnel(), numInsertions);

android/guava/src/com/google/common/hash/BloomFilter.java

@@ -220,9 +220,17 @@ public long approximateElementCount() {
         -Math.log1p(-fractionOfBitsSet) * bitSize / numHashFunctions, RoundingMode.HALF_UP);
   }
 
-  /** Returns the number of bits in the underlying bit array. */
-  @VisibleForTesting
-  long bitSize() {
+  /**
+   * Returns the number of bits in the underlying bit array.
+   *
+   * <p>This can be useful when pre-allocating space for serialization. The number of bytes written
+   * by {@link #writeTo(OutputStream)} is {@code bitSize() / 8 + 6} (6 bytes for the header: 1 byte
+   * for the strategy, 1 byte for the number of hash functions, and 4 bytes for the array length).
+   *
+   * @return the number of bits in this Bloom filter's underlying bit array
+   * @since 35.0
+   */
+  public long bitSize() {
     return bits.bitSize();
   }
 

guava-tests/test/com/google/common/hash/BloomFilterTest.java

@@ -355,6 +355,47 @@ public void testBitSize() {
     }
   }
 
+  /**
+   * Tests that bitSize() can be used to predict the serialization size produced by writeTo().
+   *
+   * <p>The serialization format consists of a 6-byte header (1 byte strategy, 1 byte hash
+   * functions, 4 bytes array length) followed by the bit array data (bitSize / 8 bytes).
+   */
+  public void testBitSizeMatchesSerializationSize() throws Exception {
+    int[] expectedInsertionValues = {1, 10, 100, 1000, 10000};
+    double[] fppValues = {0.01, 0.03, 0.1};
+
+    for (int expectedInsertions : expectedInsertionValues) {
+      for (double fpp : fppValues) {
+        BloomFilter<String> bf =
+            BloomFilter.create(Funnels.unencodedCharsFunnel(), expectedInsertions, fpp);
+
+        // Add some elements
+        for (int i = 0; i < expectedInsertions / 2; i++) {
+          bf.put("element" + i);
+        }
+
+        // Calculate expected size based on bitSize()
+        // Header: 1 byte (strategy) + 1 byte (hash functions) + 4 bytes (array length) = 6 bytes
+        // Data: bitSize / 8 bytes
+        long predictedSize = bf.bitSize() / 8 + 6;
+
+        // Serialize and measure actual size
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        bf.writeTo(out);
+        int actualSize = out.size();
+
+        assertEquals(
+            "Serialization size mismatch for expectedInsertions="
+                + expectedInsertions
+                + " fpp="
+                + fpp,
+            predictedSize,
+            actualSize);
+      }
+    }
+  }
+
   public void testApproximateElementCount() {
     int numInsertions = 1000;
     BloomFilter<Integer> bf = BloomFilter.create(Funnels.integerFunnel(), numInsertions);

guava/src/com/google/common/hash/BloomFilter.java

@@ -232,9 +232,17 @@ public long approximateElementCount() {
         -Math.log1p(-fractionOfBitsSet) * bitSize / numHashFunctions, RoundingMode.HALF_UP);
   }
 
-  /** Returns the number of bits in the underlying bit array. */
-  @VisibleForTesting
-  long bitSize() {
+  /**
+   * Returns the number of bits in the underlying bit array.
+   *
+   * <p>This can be useful when pre-allocating space for serialization. The number of bytes written
+   * by {@link #writeTo(OutputStream)} is {@code bitSize() / 8 + 6} (6 bytes for the header: 1 byte
+   * for the strategy, 1 byte for the number of hash functions, and 4 bytes for the array length).
+   *
+   * @return the number of bits in this Bloom filter's underlying bit array
+   * @since 35.0
+   */
+  public long bitSize() {
     return bits.bitSize();
   }