This question is the second iteration of Counting Bloom filter library in Java. I did nothing more but fixing the remove method in order to fix an issue mentioned by JS1. I will present only the actual filter implementation as all other bricks required for running a demonstration are there.BloomFilter.java:package net.coderodde.util;/** * This class implements a counting Bloom filter which allows not only  * inserting, querying, but deleting an element as well. *  * @author Rodion rodde Efremov * @version 1.6 * @param <T> the filter element type. */public class BloomFilter<T> {    /**     * The minimum capacity of the counter array.     */    private static final int MINIMUM_CAPACITY = 128;    /**     * The array holding the counts of each bucket.     */    private final int[] array;    /**     * The array of hash functions.     */    private final AbstractHashFunction[] hashFunctions;    /**     * The array of indices returned by the hash functions. Used for handling      * the removal of elements from the filter.     */    private final int[] indexArray;    /**     * Constructs a counting Bloom filter with array capacity {@code capacity}     * and given hash functions.     *      * @param capacity           the capacity of the counter array.     * @param firstHashFunction  the mandatory hash function.     * @param otherHashFunctions the array of voluntary hash functions.     */    public BloomFilter(int capacity,                        AbstractHashFunction<T> firstHashFunction,                       AbstractHashFunction<T>... otherHashFunctions) {        capacity = Math.max(capacity, MINIMUM_CAPACITY);        this.array = new int[capacity];        this.hashFunctions =                 new AbstractHashFunction[otherHashFunctions.length + 1];        this.hashFunctions[otherHashFunctions.length] = firstHashFunction;        System.arraycopy(otherHashFunctions,                          0,                          this.hashFunctions,                          0,                          otherHashFunctions.length);        this.indexArray = new int[hashFunctions.length];    }    /**     * Adds an element to this filter. Works by computing the hash values of the      * element and increments the counters indexed by those hash values.     *      * @param element the element to add.     */    public void add(T element) {        for (AbstractHashFunction<T> hashFunction : hashFunctions) {            array[Math.abs(hashFunction.hash(element)) % array.length]++;        }    }    /**     * Queries whether {@code element} is possibly in the filter. This may give     * false positives, but never false negatives. A false positive is the      * situation where an element is reported to be in the filter when it was      * never added to it. A false negative is the situation where an element     * is reported not being in the filter when it was actually added to the      * filter.     *      * @param element the element to query.     * @return {@code false} if the element is definitely not in the filter, and     *         {@code true} otherwise.     */    public boolean contains(T element) {        for (AbstractHashFunction<T> hashFunction : hashFunctions) {            if (array[Math.abs(hashFunction.hash(element)) %                     array.length] == 0) {                return false;            }        }        return true;    }    /**     * Removes the {@code element} from this filter. In the first pass, this     * operation makes sure that there is chance that the input element was      * added to this filter. If so, it decrements the counters indexed by the      * hash values.     *      * @param element the element to remove.     */    public void remove(T element) {        if (contains(element)) {            int hashFunctionIndex = 0;            for (AbstractHashFunction<T> hashFunction : hashFunctions) {                indexArray[hashFunctionIndex++] =                         Math.abs(hashFunction.hash(element)) % array.length;            }            for (int i = 0; i < indexArray.length; ++i) {                if (array[indexArray[i]] == 0) {                    for (int j = 0; j < i; ++j) {                        array[indexArray[j]]++;                    }                    return;                } else {                    array[indexArray[i]]--;                }            }        }    }}Any improvements possible?
Counting Bloom filter library in Java - follow-up
java;bloom filter