/*     * BitSets are packed into arrays of "words."  Currently a word is     * a long, which consists of 64 bits, requiring 6 address bits.     * The choice of word size is determined purely by performance concerns.     */    private final static int ADDRESS_BITS_PER_WORD = 6;    private final static int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD;    private final static int BIT_INDEX_MASK = BITS_PER_WORD - 1;    /* Used to shift left or right for a partial word mask */    private static final long WORD_MASK = 0xffffffffffffffffL;/**     * The internal field corresponding to the serialField "bits".     */    private long[] words;    /**     * The number of words in the logical size of this BitSet.     */    private transient int wordsInUse = 0;/**     * Given a bit index, return word index containing it.     */    private static int wordIndex(int bitIndex) {        return bitIndex >> ADDRESS_BITS_PER_WORD;    }/**     * Creates a new bit set. All bits are initially {@code false}.     */    public BitSet() {        initWords(BITS_PER_WORD);        sizeIsSticky = false;    }/**     * Creates a bit set whose initial size is large enough to explicitly     * represent bits with indices in the range {@code 0} through     * {@code nbits-1}. All bits are initially {@code false}.     *     * @param  nbits the initial size of the bit set     * @throws NegativeArraySizeException if the specified initial size     *         is negative     */    public BitSet(int nbits) {        // nbits can‘t be negative; size 0 is OK        if (nbits < 0)            throw new NegativeArraySizeException("nbits < 0: " + nbits);        initWords(nbits);        sizeIsSticky = true;    }    private void initWords(int nbits) {        words = new long[wordIndex(nbits-1) + 1];    }   /**     * Sets the bit at the specified index to {@code true}.     *     * @param  bitIndex a bit index     * @throws IndexOutOfBoundsException if the specified index is negative     * @since  JDK1.0     */    public void set(int bitIndex) {        if (bitIndex < 0)            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);        int wordIndex = wordIndex(bitIndex);        expandTo(wordIndex);        words[wordIndex] |= (1L << bitIndex); // Restores invariants        checkInvariants();    }    /**     * Sets the bit at the specified index to the specified value.     *     * @param  bitIndex a bit index     * @param  value a boolean value to set     * @throws IndexOutOfBoundsException if the specified index is negative     * @since  1.4     */    public void set(int bitIndex, boolean value) {        if (value)            set(bitIndex);        else            clear(bitIndex);    }/**     * Sets the bit specified by the index to {@code false}.     *     * @param  bitIndex the index of the bit to be cleared     * @throws IndexOutOfBoundsException if the specified index is negative     * @since  JDK1.0     */    public void clear(int bitIndex) {        if (bitIndex < 0)            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);        int wordIndex = wordIndex(bitIndex);        if (wordIndex >= wordsInUse)            return;        words[wordIndex] &= ~(1L << bitIndex);        recalculateWordsInUse();        checkInvariants();    }