/** * Creates a new MultiArrangement using the elements of an array. * * @param keyArray the array of keys of the new MultiArrangement. * @param f the load factor. * @throws IllegalArgumentException if <code>k</code> and <code>v</code> have different lengths. */ public MultiArrangement(final K[] keyArray, final float f) { this(keyArray.length, f); for (int i = 0; i < keyArray.length; i++) add(keyArray[i]); }
/** * Creates a new Arrangement using the elements of two parallel arrays. * * @param keyArray the array of keys of the new Arrangement. * @param f the load factor. * @param hasher used to hash items; typically only needed when K is an array, where CrossHash has implementations * @throws IllegalArgumentException if <code>k</code> and <code>v</code> have different lengths. */ public MultiArrangement(final K[] keyArray, final float f, CrossHash.IHasher hasher) { this(keyArray.length, f, hasher); for (int i = 0; i < keyArray.length; i++) add(keyArray[i]); } /**
/** * Creates a new Arrangement using the given collection of keys. * * @param keyColl the collection of keys of the new Arrangement. * @param f the load factor. * @throws IllegalArgumentException if <code>k</code> and <code>v</code> have different lengths. */ public MultiArrangement(final Collection<K> keyColl, final float f) { this(keyColl.size(), f); Iterator<K> ki = keyColl.iterator(); int idx = 0; while (ki.hasNext()) { add(ki.next()); } }
public int addIfAbsent(final K k) { int kPos; if(containsKey(k)) return add(k); return -1; }
public void addAll(Collection<? extends K> keyArray) { if (f <= .5) ensureCapacity(keyArray.size()); // The resulting map will be sized for // m.size() elements else tryCapacity(size() + keyArray.size()); // The resulting map will be Iterator<? extends K> it = keyArray.iterator(); while (it.hasNext()) add(it.next()); } public void addAllIfAbsent(Map<? extends K, ? extends Integer> m) {
/** * Produces a copy of this MultiArrangement, but only using up to the given amount of items to take. Does a shallow copy * of individual keys, so the references will be shared. * @param amount the number of items to copy from this MultiArrangement; will copy all items if greater than size * @return a new MultiArrangement with up to amount items copied from this into it. */ public MultiArrangement<K> take(int amount) { amount = Math.min(order.size, Math.max(0, amount)); MultiArrangement<K> nx = new MultiArrangement<>(amount, f); for (int i = 0; i < amount; i++) { nx.add(keyAt(i)); } return nx; } protected int positionOf(final Object k) {
public void addAll(K[] keyArray) { if (f <= .5) ensureCapacity(keyArray.length); // The resulting map will be sized for // m.size() elements else tryCapacity(size() + keyArray.length); // The resulting map will be int n = keyArray.length; for (int i = 0; i < n; i++) { add(keyArray[i]); } }
return add(replacement) >= 0; return add(replacement) >= 0; if (hasher.areEqual(original, curr)) return alterEntry(pos, replacement); while (true) { if ((curr = key[pos = (pos + 1) & mask]) == null) return add(replacement) >= 0; if (hasher.areEqual(original, curr)) return alterEntry(pos, replacement);