@Override
public V remove(final Object key) {
final Entry<K, V>[] table = this.table;
final int hash = key.hashCode();
final int index = HashUtil.indexFor(hash, table.length, shift, mask);
Entry<K, V> e = table[index];
if (e == null) return null;
K entryKey;
if (e.keyHash == hash && ((entryKey = e.key) == key || entryKey.equals(key))) {
table[index] = e.hashNext;
} else {
for (; ; ) {
final Entry<K, V> last = e;
e = e.hashNext;
if (e == null) return null;
if (e.keyHash == hash && ((entryKey = e.key) == key || entryKey.equals(key))) {
last.hashNext = e.hashNext;
break;
}
}
}
unlink(e);
size = size - 1;
return e.value;
}
@Override
public V put(final K key, final V value) {
final Entry<K, V>[] table = this.table;
final int hash = key.hashCode();
final int index = HashUtil.indexFor(hash, table.length, shift, mask);
for (Entry<K, V> e = table[index]; e != null; e = e.hashNext) {
final K entryKey;
if (e.keyHash == hash && ((entryKey = e.key) == key || entryKey.equals(key))) {
moveToTop(e);
return e.setValue(value);
}
}
final Entry<K, V> e = new Entry<K, V>(key, value);
e.hashNext = table[index];
table[index] = e;
final Entry<K, V> top = this.top;
e.next = top;
if (top != null) {
top.previous = e;
} else {
back = e;
}
this.top = e;
size = size + 1;
if (removeEldestEntry(back)) {
remove(back.key);
} else if (size > capacity) {
rehash(HashUtil.nextCapacity(capacity));
}
return null;
}
private Entry<V> getEntry(final int key) {
final Entry<V>[] table = this.table;
final int index = HashUtil.indexFor(key, table.length, mask);
for (Entry<V> e = table[index]; e != null; e = e.hashNext) {
if (e.key == key) {
return e;
}
}
return null;
}
public boolean contains(final int key) {
final Entry[] table = this.table;
final int index = HashUtil.indexFor(key, table.length, shift, mask);
for (Entry e = table[index]; e != null; e = e.hashNext) {
if (e.key == key) {
return true;
}
}
return false;
}
private void rehash(int capacity) {
final int length = HashUtil.adjustTableLength((int) (capacity / loadFactor));
this.capacity = capacity;
if (length != table.length) {
allocateTable(length);
final Entry<K, V>[] table = this.table;
final int shift = this.shift;
final int mask = this.mask;
for (Entry<K, V> e = back; e != null; e = e.previous) {
final int index = HashUtil.indexFor(e.keyHash, length, shift, mask);
e.hashNext = table[index];
table[index] = e;
}
}
}
private void rehash(int capacity) {
final int length = HashUtil.getCeilingPrime((int) (capacity / loadFactor));
this.capacity = capacity;
if (length != table.length) {
final Iterator<Map.Entry<Integer, V>> entries = entrySet().iterator();
allocateTable(length);
final Entry<V>[] table = this.table;
final int mask = this.mask;
while (entries.hasNext()) {
final Entry<V> e = (Entry<V>) entries.next();
final int index = HashUtil.indexFor(e.key, length, mask);
e.hashNext = table[index];
table[index] = e;
}
}
}
@Override
protected Map.Entry<K, V> getEntry(Object key) {
final Entry<K, V>[] table = this.table;
final int hash = key.hashCode();
final int index = HashUtil.indexFor(hash, table.length, shift, mask);
for (Entry<K, V> e = table[index]; e != null; e = e.hashNext) {
final K entryKey;
if (e.keyHash == hash && ((entryKey = e.key) == key || entryKey.equals(key))) {
moveToTop(e);
return e;
}
}
return null;
}
private void rehash(int capacity) {
final int length = HashUtil.getCeilingPrime((int) (capacity / loadFactor));
this.capacity = capacity;
if (length != table.length) {
final Iterator<Entry> entries = new RehashIterator();
allocateTable(length);
final Entry[] table = this.table;
final int shift = this.shift;
final int mask = this.mask;
while (entries.hasNext()) {
final Entry e = entries.next();
final int index = HashUtil.indexFor(e.key, length, shift, mask);
e.hashNext = table[index];
table[index] = e;
}
}
}
public V put(final int key, final V value) {
final Entry<V>[] table = this.table;
final int index = HashUtil.indexFor(key, table.length, mask);
for (Entry<V> e = table[index]; e != null; e = e.hashNext) {
if (e.key == key) {
return e.setValue(value);
}
}
final Entry<V> e = new Entry<>(key, value);
e.hashNext = table[index];
table[index] = e;
size += 1;
if (size > capacity) {
rehash(HashUtil.nextCapacity(capacity));
}
return null;
}
public boolean add(final int key) {
final Entry[] table = this.table;
final int index = HashUtil.indexFor(key, table.length, shift, mask);
for (Entry e = table[index]; e != null; e = e.hashNext) {
if (e.key == key) {
return false;
}
}
final Entry e = new Entry(key);
e.hashNext = table[index];
table[index] = e;
size += 1;
if (size > capacity) {
rehash(HashUtil.nextCapacity(capacity));
}
return true;
}
public V remove(final int key) {
final Entry<V>[] table = this.table;
final int index = HashUtil.indexFor(key, table.length, mask);
Entry<V> e = table[index];
if (e == null) return null;
if (e.key == key) {
table[index] = e.hashNext;
} else {
for (; ; ) {
final Entry<V> last = e;
e = e.hashNext;
if (e == null) return null;
if (e.key == key) {
last.hashNext = e.hashNext;
break;
}
}
}
size -= 1;
return e.value;
}
public boolean remove(int key) {
final Entry[] table = this.table;
final int index = HashUtil.indexFor(key, table.length, shift, mask);
Entry e = table[index];
if (e == null) return false;
if (e.key == key) {
table[index] = e.hashNext;
} else {
for (; ; ) {
final Entry last = e;
e = e.hashNext;
if (e == null) return false;
if (e.key == key) {
last.hashNext = e.hashNext;
break;
}
}
}
size -= 1;
return true;
}
