How to use

resize

method

in

com.badlogic.gdx.utils.IntSet

/** Clears the set and reduces the size of the backing arrays to be the specified capacity if they are larger. */
public void clear (int maximumCapacity) {
  if (capacity <= maximumCapacity) {
    clear();
    return;
  }
  hasZeroValue = false;
  size = 0;
  resize(maximumCapacity);
}

/** Increases the size of the backing array to accommodate the specified number of additional items. Useful before adding many
 * items to avoid multiple backing array resizes. */
public void ensureCapacity (int additionalCapacity) {
  if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
  int sizeNeeded = size + additionalCapacity;
  if (sizeNeeded >= threshold) resize(MathUtils.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
}

/** Reduces the size of the backing arrays to be the specified capacity or less. If the capacity is already less, nothing is
 * done. If the set contains more items than the specified capacity, the next highest power of two capacity is used instead. */
public void shrink (int maximumCapacity) {
  if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
  if (size > maximumCapacity) maximumCapacity = size;
  if (capacity <= maximumCapacity) return;
  maximumCapacity = MathUtils.nextPowerOfTwo(maximumCapacity);
  resize(maximumCapacity);
}

/** Clears the set and reduces the size of the backing arrays to be the specified capacity if they are larger. */
public void clear (int maximumCapacity) {
  if (capacity <= maximumCapacity) {
    clear();
    return;
  }
  hasZeroValue = false;
  size = 0;
  resize(maximumCapacity);
}

/** Increases the size of the backing array to accommodate the specified number of additional items. Useful before adding many
 * items to avoid multiple backing array resizes. */
public void ensureCapacity (int additionalCapacity) {
  if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
  int sizeNeeded = size + additionalCapacity;
  if (sizeNeeded >= threshold) resize(MathUtils.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
}

/** Reduces the size of the backing arrays to be the specified capacity or less. If the capacity is already less, nothing is
 * done. If the set contains more items than the specified capacity, the next highest power of two capacity is used instead. */
public void shrink (int maximumCapacity) {
  if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
  if (size > maximumCapacity) maximumCapacity = size;
  if (capacity <= maximumCapacity) return;
  maximumCapacity = MathUtils.nextPowerOfTwo(maximumCapacity);
  resize(maximumCapacity);
}

private void addStash (int key) {
  if (stashSize == stashCapacity) {
    // Too many pushes occurred and the stash is full, increase the table size.
    resize(capacity << 1);
    addResize(key);
    return;
  }
  // Store key in the stash.
  int index = capacity + stashSize;
  keyTable[index] = key;
  stashSize++;
  size++;
}

private void addStash (int key) {
  if (stashSize == stashCapacity) {
    // Too many pushes occurred and the stash is full, increase the table size.
    resize(capacity << 1);
    addResize(key);
    return;
  }
  // Store key in the stash.
  int index = capacity + stashSize;
  keyTable[index] = key;
  stashSize++;
  size++;
}

/** Skips checks for existing keys. */
private void addResize (int key) {
  if (key == 0) {
    hasZeroValue = true;
    return;
  }
  // Check for empty buckets.
  int index1 = key & mask;
  int key1 = keyTable[index1];
  if (key1 == EMPTY) {
    keyTable[index1] = key;
    if (size++ >= threshold) resize(capacity << 1);
    return;
  }
  int index2 = hash2(key);
  int key2 = keyTable[index2];
  if (key2 == EMPTY) {
    keyTable[index2] = key;
    if (size++ >= threshold) resize(capacity << 1);
    return;
  }
  int index3 = hash3(key);
  int key3 = keyTable[index3];
  if (key3 == EMPTY) {
    keyTable[index3] = key;
    if (size++ >= threshold) resize(capacity << 1);
    return;
  }
  push(key, index1, key1, index2, key2, index3, key3);
}

/** Skips checks for existing keys. */
private void addResize (int key) {
  if (key == 0) {
    hasZeroValue = true;
    return;
  }
  // Check for empty buckets.
  int index1 = key & mask;
  int key1 = keyTable[index1];
  if (key1 == EMPTY) {
    keyTable[index1] = key;
    if (size++ >= threshold) resize(capacity << 1);
    return;
  }
  int index2 = hash2(key);
  int key2 = keyTable[index2];
  if (key2 == EMPTY) {
    keyTable[index2] = key;
    if (size++ >= threshold) resize(capacity << 1);
    return;
  }
  int index3 = hash3(key);
  int key3 = keyTable[index3];
  if (key3 == EMPTY) {
    keyTable[index3] = key;
    if (size++ >= threshold) resize(capacity << 1);
    return;
  }
  push(key, index1, key1, index2, key2, index3, key3);
}

if (size++ >= threshold) resize(capacity << 1);
return true;
if (size++ >= threshold) resize(capacity << 1);
return true;
if (size++ >= threshold) resize(capacity << 1);
return true;

if (size++ >= threshold) resize(capacity << 1);
return true;
if (size++ >= threshold) resize(capacity << 1);
return true;
if (size++ >= threshold) resize(capacity << 1);
return true;

if (key1 == EMPTY) {
  keyTable[index1] = evictedKey;
  if (size++ >= threshold) resize(capacity << 1);
  return;
if (key2 == EMPTY) {
  keyTable[index2] = evictedKey;
  if (size++ >= threshold) resize(capacity << 1);
  return;
if (key3 == EMPTY) {
  keyTable[index3] = evictedKey;
  if (size++ >= threshold) resize(capacity << 1);
  return;

if (key1 == EMPTY) {
  keyTable[index1] = evictedKey;
  if (size++ >= threshold) resize(capacity << 1);
  return;
if (key2 == EMPTY) {
  keyTable[index2] = evictedKey;
  if (size++ >= threshold) resize(capacity << 1);
  return;
if (key3 == EMPTY) {
  keyTable[index3] = evictedKey;
  if (size++ >= threshold) resize(capacity << 1);
  return;

/** Reduces the size of the backing arrays to be the specified capacity or less. If the capacity is already less, nothing is
 * done. If the set contains more items than the specified capacity, the next highest power of two capacity is used instead. */
public void shrink (int maximumCapacity) {
  if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
  if (size > maximumCapacity) maximumCapacity = size;
  if (capacity <= maximumCapacity) return;
  maximumCapacity = MathUtils.nextPowerOfTwo(maximumCapacity);
  resize(maximumCapacity);
}

/** Increases the size of the backing array to accommodate the specified number of additional items. Useful before adding many
 * items to avoid multiple backing array resizes. */
public void ensureCapacity (int additionalCapacity) {
  if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
  int sizeNeeded = size + additionalCapacity;
  if (sizeNeeded >= threshold) resize(MathUtils.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
}

/** Clears the set and reduces the size of the backing arrays to be the specified capacity if they are larger. */
public void clear (int maximumCapacity) {
  if (capacity <= maximumCapacity) {
    clear();
    return;
  }
  hasZeroValue = false;
  size = 0;
  resize(maximumCapacity);
}

private void addStash (int key) {
  if (stashSize == stashCapacity) {
    // Too many pushes occurred and the stash is full, increase the table size.
    resize(capacity << 1);
    addResize(key);
    return;
  }
  // Store key in the stash.
  int index = capacity + stashSize;
  keyTable[index] = key;
  stashSize++;
  size++;
}

/** Skips checks for existing keys. */
private void addResize (int key) {
  if (key == 0) {
    hasZeroValue = true;
    return;
  }
  // Check for empty buckets.
  int index1 = key & mask;
  int key1 = keyTable[index1];
  if (key1 == EMPTY) {
    keyTable[index1] = key;
    if (size++ >= threshold) resize(capacity << 1);
    return;
  }
  int index2 = hash2(key);
  int key2 = keyTable[index2];
  if (key2 == EMPTY) {
    keyTable[index2] = key;
    if (size++ >= threshold) resize(capacity << 1);
    return;
  }
  int index3 = hash3(key);
  int key3 = keyTable[index3];
  if (key3 == EMPTY) {
    keyTable[index3] = key;
    if (size++ >= threshold) resize(capacity << 1);
    return;
  }
  push(key, index1, key1, index2, key2, index3, key3);
}

if (size++ >= threshold) resize(capacity << 1);
return true;
if (size++ >= threshold) resize(capacity << 1);
return true;
if (size++ >= threshold) resize(capacity << 1);
return true;