/** * Construct a hash set with a proposed initial capacity, load factor, and indicated iterator caching support. * * @param proposedCapacity for the initial capacity of the set. * @param loadFactor to be used for resizing. * @param shouldAvoidAllocation should the iterator be cached to avoid further allocation. */ @SuppressWarnings("unchecked") public ObjectHashSet(final int proposedCapacity, final float loadFactor, final boolean shouldAvoidAllocation) { validateLoadFactor(loadFactor); this.shouldAvoidAllocation = shouldAvoidAllocation; this.loadFactor = loadFactor; size = 0; final int capacity = findNextPositivePowerOfTwo(Math.max(DEFAULT_INITIAL_CAPACITY, proposedCapacity)); resizeThreshold = (int)(capacity * loadFactor); values = (T[])new Object[capacity]; }
/** * Construct a map that sets it initial capacity and load factor. * * @param initialCapacity for the underlying hash map * @param loadFactor for the underlying hash map */ public BiInt2ObjectMap(final int initialCapacity, final float loadFactor) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; final int capacity = findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity)); resizeThreshold = (int)(capacity * loadFactor); keys = new long[capacity]; values = new Object[capacity]; }
/** * @param initialCapacity for the map to override {@link #MIN_CAPACITY} * @param loadFactor for the map to override {@link Hashing#DEFAULT_LOAD_FACTOR}. * @param shouldAvoidAllocation should allocation be avoided by caching iterators and map entries. */ public Object2ObjectHashMap(final int initialCapacity, final float loadFactor, final boolean shouldAvoidAllocation) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.shouldAvoidAllocation = shouldAvoidAllocation; capacity(findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity))); }
/** * Construct a new map allowing a configuration for initial capacity and load factor. * @param initialCapacity for the backing array * @param loadFactor limit for resizing on puts * @param missingValue value to be used as a null marker in the map * @param shouldAvoidAllocation should allocation be avoided by caching iterators and map entries. */ @SuppressWarnings("unchecked") public Object2IntHashMap( @DoNotSub final int initialCapacity, final float loadFactor, final int missingValue, final boolean shouldAvoidAllocation) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; /* @DoNotSub */ final int capacity = findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity)); /* @DoNotSub */ resizeThreshold = (int)(capacity * loadFactor); this.missingValue = missingValue; this.shouldAvoidAllocation = shouldAvoidAllocation; keys = (K[])new Object[capacity]; values = new int[capacity]; Arrays.fill(values, missingValue); }
/** * Construct a new map allowing a configuration for initial capacity and load factor. * @param initialCapacity for the backing array * @param loadFactor limit for resizing on puts * @param shouldAvoidAllocation should allocation be avoided by caching iterators and map entries. */ public Int2ObjectHashMap( @DoNotSub final int initialCapacity, final float loadFactor, final boolean shouldAvoidAllocation) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.shouldAvoidAllocation = shouldAvoidAllocation; /* @DoNotSub */ final int capacity = findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity)); /* @DoNotSub */ resizeThreshold = (int)(capacity * loadFactor); keys = new int[capacity]; values = new Object[capacity]; }
/** * Construct a hash set with a proposed initial capacity, load factor, and indicated iterator caching support. * * @param proposedCapacity for the initial capacity of the set. * @param loadFactor to be used for resizing. * @param shouldAvoidAllocation should the iterator be cached to avoid further allocation. */ public IntHashSet( @DoNotSub final int proposedCapacity, final float loadFactor, final boolean shouldAvoidAllocation) { validateLoadFactor(loadFactor); this.shouldAvoidAllocation = shouldAvoidAllocation; this.loadFactor = loadFactor; sizeOfArrayValues = 0; @DoNotSub final int capacity = findNextPositivePowerOfTwo(Math.max(DEFAULT_INITIAL_CAPACITY, proposedCapacity)); resizeThreshold = (int)(capacity * loadFactor); // @DoNotSub values = new int[capacity]; Arrays.fill(values, MISSING_VALUE); }
public Int2IntCounterMap( @DoNotSub final int initialCapacity, @DoNotSub final float loadFactor, final int initialValue) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.initialValue = initialValue; capacity(findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity))); }
/** * @param initialCapacity for the map to override {@link #MIN_CAPACITY} * @param loadFactor for the map to override {@link Hashing#DEFAULT_LOAD_FACTOR}. * @param missingValue for the map that represents null. * @param shouldAvoidAllocation should allocation be avoided by caching iterators and map entries. */ public Int2IntHashMap( @DoNotSub final int initialCapacity, @DoNotSub final float loadFactor, final int missingValue, final boolean shouldAvoidAllocation) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.missingValue = missingValue; this.shouldAvoidAllocation = shouldAvoidAllocation; capacity(findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity))); }
/** * Construct a map that sets it initial capacity and load factor. * * @param initialCapacity for the underlying hash map * @param loadFactor for the underlying hash map */ public BiInt2ObjectMap(final int initialCapacity, final float loadFactor) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; final int capacity = BitUtil.findNextPositivePowerOfTwo(initialCapacity); resizeThreshold = (int)(capacity * loadFactor); keys = new long[capacity]; values = new Object[capacity]; }
/** * Construct a map that sets it initial capacity and load factor. * * @param initialCapacity for the underlying hash map * @param loadFactor for the underlying hash map */ public BiInt2ObjectMap(final int initialCapacity, final float loadFactor) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; final int capacity = findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity)); resizeThreshold = (int)(capacity * loadFactor); keys = new long[capacity]; values = new Object[capacity]; }
/** * @param initialCapacity for the map to override {@link #MIN_CAPACITY} * @param loadFactor for the map to override {@link Hashing#DEFAULT_LOAD_FACTOR}. * @param shouldAvoidAllocation should allocation be avoided by caching iterators and map entries. */ public Object2ObjectHashMap(final int initialCapacity, final float loadFactor, final boolean shouldAvoidAllocation) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.shouldAvoidAllocation = shouldAvoidAllocation; capacity(findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity))); }
@SuppressWarnings("unchecked") public ObjectHashSet(final int initialCapacity, final float loadFactor) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; size = 0; final int capacity = BitUtil.findNextPositivePowerOfTwo(initialCapacity); resizeThreshold = (int)(capacity * loadFactor); values = (T[])new Object[capacity]; Arrays.fill(values, MISSING_VALUE); // NB: references values in the constructor, so must be assigned after values iterator = new ObjectHashSetIterator(values); }
public Long2LongCounterMap( @DoNotSub final int initialCapacity, @DoNotSub final float loadFactor, final long initialValue) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.initialValue = initialValue; capacity(findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity))); }
public Int2IntCounterMap( @DoNotSub final int initialCapacity, @DoNotSub final float loadFactor, final int initialValue) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.initialValue = initialValue; capacity(findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity))); }
public LongHashSet( @DoNotSub final int initialCapacity, final long missingValue, final float loadFactor) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; size = 0; this.missingValue = missingValue; @DoNotSub final int capacity = BitUtil.findNextPositivePowerOfTwo(initialCapacity); resizeThreshold = (int)(capacity * loadFactor); // @DoNotSub values = new long[capacity]; Arrays.fill(values, missingValue); // NB: references values in the constructor, so must be assigned after values iterator = new LongHashSetIterator(missingValue, values); }
/** * @param initialCapacity for the map to override {@link #MIN_CAPACITY} * @param loadFactor for the map to override {@link Hashing#DEFAULT_LOAD_FACTOR}. * @param missingValue for the map that represents null. * @param shouldAvoidAllocation should allocation be avoided by caching iterators and map entries. */ public Long2LongHashMap( @DoNotSub final int initialCapacity, @DoNotSub final float loadFactor, final long missingValue, final boolean shouldAvoidAllocation) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.missingValue = missingValue; this.shouldAvoidAllocation = shouldAvoidAllocation; capacity(findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity))); }
/** * @param initialCapacity for the map to override {@link #MIN_CAPACITY} * @param loadFactor for the map to override {@link Hashing#DEFAULT_LOAD_FACTOR}. * @param missingValue for the map that represents null. * @param shouldAvoidAllocation should allocation be avoided by caching iterators and map entries. */ public Int2IntHashMap( @DoNotSub final int initialCapacity, @DoNotSub final float loadFactor, final int missingValue, final boolean shouldAvoidAllocation) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.missingValue = missingValue; this.shouldAvoidAllocation = shouldAvoidAllocation; capacity(findNextPositivePowerOfTwo(Math.max(MIN_CAPACITY, initialCapacity))); }
public IntHashSet( @DoNotSub final int initialCapacity, final int missingValue, final float loadFactor) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; size = 0; this.missingValue = missingValue; @DoNotSub final int capacity = BitUtil.findNextPositivePowerOfTwo(initialCapacity); resizeThreshold = (int)(capacity * loadFactor); // @DoNotSub values = new int[capacity]; Arrays.fill(values, missingValue); // NB: references values in the constructor, so must be assigned after values iterator = new IntHashSetIterator(missingValue, values); }
@SuppressWarnings("unchecked") public Int2IntHashMap( @DoNotSub final int initialCapacity, @DoNotSub final float loadFactor, final int missingValue) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.missingValue = missingValue; capacity(BitUtil.findNextPositivePowerOfTwo(initialCapacity)); keySet = new KeySet(); values = new Values(); entrySet = new EntrySet(); }
@SuppressWarnings("unchecked") public Long2LongHashMap( @DoNotSub final int initialCapacity, @DoNotSub final float loadFactor, final long missingValue) { validateLoadFactor(loadFactor); this.loadFactor = loadFactor; this.missingValue = missingValue; capacity(BitUtil.findNextPositivePowerOfTwo(initialCapacity)); keySet = new KeySet(); values = new Values(); entrySet = new EntrySet(); }