code: private SimpleHashSetEntry<T>[] doubleCapacity() {
          SimpleHashSetEntry<T>[] oldTable = mTable;
          int oldCapacity = oldTable.length;
          if (oldCapacity == MAXIMUM_CAPACITY) {
              return oldTable;
          }
          int newCapacity = oldCapacity * 2;
          SimpleHashSetEntry<T>[] newTable = makeTable(newCapacity);
          if (mSize == 0) {
              return newTable;
          }
  
          for (int j = 0; j < oldCapacity; j++) {
              /*
               * Rehash the bucket using the minimum number of field writes.
               * This is the most subtle and delicate code in the class.
               */
              SimpleHashSetEntry<T> e = oldTable[j];
              if (e == null) {
                  continue;
              }
              int highBit = e.mHash & oldCapacity;
              SimpleHashSetEntry<T> broken = null;
              newTable[j | highBit] = e;
              for (SimpleHashSetEntry<T> n = e.mNext; n != null; e = n, n = n.mNext) {
                  int nextHighBit = n.mHash & oldCapacity;
                  if (nextHighBit != highBit) {
                      if (broken == null) {
                          newTable[j | nextHighBit] = n;
                      } else {
                          broken.mNext = n;
                      }
                      broken = e;
                      highBit = nextHighBit;
                  }
              }
              if (broken != null)
                  broken.mNext = null;
          }
          return newTable;
      }
docs: Doubles the capacity of the hash table. Existing entries are placed in
  the correct bucket on the enlarged table. If the current capacity is,
  MAXIMUM_CAPACITY, this method is a no-op. Returns the table, which
  will be new unless we were already at MAXIMUM_CAPACITY.