/** * {@inheritDoc} */ public boolean isEmpty() { return size() == 0; }
/** * {@inheritDoc} */ public void clear() { if (size() > 0) { Arrays.fill(values, MISSING_VALUE); sizeOfArrayValues = 0; containsMissingValue = false; } }
/** * {@inheritDoc} */ public Object[] toArray() { final Object[] arrayCopy = new Object[size()]; copyValues(arrayCopy); return arrayCopy; }
private void increaseCapacity() { @DoNotSub final int newCapacity = values.length * 2; if (newCapacity < 0) { throw new IllegalStateException("max capacity reached at size=" + size()); } rehash(newCapacity); }
/** * {@inheritDoc} */ @SuppressWarnings("unchecked") public <T> T[] toArray(final T[] into) { final Class<?> componentType = into.getClass().getComponentType(); if (!componentType.isAssignableFrom(Integer.class)) { throw new ArrayStoreException("cannot store Integers in array of type " + componentType); } @DoNotSub final int size = size(); final T[] arrayCopy = into.length >= size ? into : (T[])Array.newInstance(componentType, size); copyValues(arrayCopy); return arrayCopy; }
/** * Compact the backing arrays by rehashing with a capacity just larger than current size * and giving consideration to the load factor. */ public void compact() { @DoNotSub final int idealCapacity = (int)Math.round(size() * (1.0 / loadFactor)); rehash(findNextPositivePowerOfTwo(Math.max(DEFAULT_INITIAL_CAPACITY, idealCapacity))); }
IntIterator reset() { this.remaining = size(); final int[] values = IntHashSet.this.values; @DoNotSub final int length = values.length; @DoNotSub int i = length; if (values[length - 1] != IntHashSet.MISSING_VALUE) { for (i = 0; i < length; i++) { if (values[i] == IntHashSet.MISSING_VALUE) { break; } } } stopCounter = i; positionCounter = i + length; isPositionValid = false; return this; }
if (c.size() != size())
@Test public void sizeIsInitiallyZero() { assertEquals(0, testSet.size()); }
@Test @SuppressWarnings("ToArrayCallWithZeroLengthArrayArgument") public void toArraySupportsEmptyCollection() { final Integer[] result = testSet.toArray(new Integer[testSet.size()]); assertArrayEquals(result, new Integer[]{}); }
@Test public void sizeIncrementsWithNumberOfAddedElements() { addTwoElements(testSet); assertEquals(2, testSet.size()); }
@Test @SuppressWarnings("ToArrayCallWithZeroLengthArrayArgument") public void toArrayCopiesElementsIntoSufficientlySizedArray() { addTwoElements(testSet); final Integer[] result = testSet.toArray(new Integer[testSet.size()]); assertArrayContainingElements(result); }
@Test @SuppressWarnings("ToArrayCallWithZeroLengthArrayArgument") public void toArrayCopiesElementsIntoNewArray() { addTwoElements(testSet); final Integer[] result = testSet.toArray(new Integer[testSet.size()]); assertArrayContainingElements(result); }
@Test public void sizeAccountsForMissingValue() { testSet.add(1); testSet.add(MISSING_VALUE); assertEquals(2, testSet.size()); }
@Test @SuppressWarnings("OverwrittenKey") public void sizeContainsNumberOfNewElements() { testSet.add(1); testSet.add(1); assertEquals(1, testSet.size()); }
@Test public void reducesSizeWhenElementRemoved() { addTwoElements(testSet); testSet.remove(1001); assertEquals(1, testSet.size()); }
@Test @SuppressWarnings("ToArrayCallWithZeroLengthArrayArgument") public void toArrayCopiesElementsIntoNewArrayIncludingMissingValue() { addTwoElements(testSet); testSet.add(MISSING_VALUE); final Integer[] result = testSet.toArray(new Integer[testSet.size()]); assertThat(result, arrayContainingInAnyOrder(1, 1001, MISSING_VALUE)); }
@Test public void clearRemovesAllElementsOfTheSet() { addTwoElements(testSet); testSet.clear(); assertEquals(0, testSet.size()); assertFalse(testSet.contains(1)); assertFalse(testSet.contains(1001)); }
/** * {@inheritDoc} */ public boolean isEmpty() { return size() == 0; }
/** * {@inheritDoc} */ public Object[] toArray() { final Object[] arrayCopy = new Object[size()]; copyValues(arrayCopy); return arrayCopy; }