bitVector@ java bit自我practice##Q&A：为何int 来初始化size of bitVector？long，甚至是BigInteger等策略

/*

     * 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();

    }