HashMap 添加元素
public V put ( K key, V value) {
if ( table == EMPTY_TABLE) {
inflateTable ( threshold) ;
}
if ( key == null )
return putForNullKey ( value) ;
int hash = hash ( key) ;
int i = indexFor ( hash, table. length) ;
for ( Entry < K , V > e = table[ i] ; e != null ; e = e. next) {
Object k;
if ( e. hash == hash && ( ( k = e. key) == key || key. equals ( k) ) ) {
V oldValue = e. value;
e. value = value;
e. recordAccess ( this ) ;
return oldValue;
}
}
modCount++ ;
addEntry ( hash, key, value, i) ;
return null ;
}
private void inflateTable ( int toSize) {
int capacity = roundUpToPowerOf2 ( toSize) ;
threshold = ( int ) Math . min ( capacity * loadFactor, MAXIMUM_CAPACITY + 1 ) ;
table = new Entry [ capacity] ;
initHashSeedAsNeeded ( capacity) ;
}
private static int roundUpToPowerOf2 ( int number) {
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: ( number > 1 ) ? Integer . highestOneBit ( ( number - 1 ) << 1 ) : 1 ;
}
public static int highestOneBit ( int i) {
i |= ( i >> 1 ) ;
i |= ( i >> 2 ) ;
i |= ( i >> 4 ) ;
i |= ( i >> 8 ) ;
i |= ( i >> 16 ) ;
return i - ( i >>> 1 ) ;
}
final int hash ( Object k) {
int h = hashSeed;
if ( 0 != h && k instanceof String ) {
return sun. misc. Hashing. stringHash32 ( ( String ) k) ;
}
h ^= k. hashCode ( ) ;
h ^= ( h >>> 20 ) ^ ( h >>> 12 ) ;
return h ^ ( h >>> 7 ) ^ ( h >>> 4 ) ;
}
static int indexFor ( int h, int length) {
return h & ( length- 1 ) ;
}
void addEntry ( int hash, K key, V value, int bucketIndex) {
if ( ( size >= threshold) && ( null != table[ bucketIndex] ) ) {
resize ( 2 * table. length) ;
hash = ( null != key) ? hash ( key) : 0 ;
bucketIndex = indexFor ( hash, table. length) ;
}
createEntry ( hash, key, value, bucketIndex) ;
}
void resize ( int newCapacity) {
Entry [ ] oldTable = table;
int oldCapacity = oldTable. length;
if ( oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer . MAX_VALUE;
return ;
}
Entry [ ] newTable = new Entry [ newCapacity] ;
transfer ( newTable, initHashSeedAsNeeded ( newCapacity) ) ;
table = newTable;
threshold = ( int ) Math . min ( newCapacity * loadFactor, MAXIMUM_CAPACITY + 1 ) ;
}
void transfer ( Entry [ ] newTable, boolean rehash) {
int newCapacity = newTable. length;
for ( Entry < K , V > e : table) {
while ( null != e) {
Entry < K , V > next = e. next;
if ( rehash) {
e. hash = null == e. key ? 0 : hash ( e. key) ;
}
int i = indexFor ( e. hash, newCapacity) ;
e. next = newTable[ i] ;
newTable[ i] = e;
e = next;
}
}
}
void createEntry ( int hash, K key, V value, int bucketIndex) {
Entry < K , V > e = table[ bucketIndex] ;
table[ bucketIndex] = new Entry < > ( hash, key, value, e) ;
size++ ;
}
HashMap 遍历
public Set < Map. Entry < K , V > > entrySet ( ) {
return entrySet0 ( ) ;
}
private Set < Map. Entry < K , V > > entrySet0 ( ) {
Set < Map. Entry < K , V > > es = entrySet;
return es != null ? es : ( entrySet = new EntrySet ( ) ) ;
}
private final class EntrySet extends AbstractSet < Map. Entry < K , V > > {
public Iterator < Map. Entry < K , V > > iterator ( ) {
return newEntryIterator ( ) ;
}
public boolean contains ( Object o) {
if ( ! ( o instanceof Map. Entry ) )
return false ;
Map. Entry < K , V > e = ( Map. Entry < K , V > ) o;
Entry < K , V > candidate = getEntry ( e. getKey ( ) ) ;
return candidate != null && candidate. equals ( e) ;
}
public boolean remove ( Object o) {
return removeMapping ( o) != null ;
}
public int size ( ) {
return size;
}
public void clear ( ) {
HashMap . this . clear ( ) ;
}
}
Iterator < Map. Entry < K , V > > newEntryIterator ( ) {
return new EntryIterator ( ) ;
}
private final class EntryIterator extends HashIterator < Map. Entry < K , V > > {
public Map. Entry < K , V > next ( ) {
return nextEntry ( ) ;
}
}
private abstract class HashIterator < E > implements Iterator < E > {
Entry < K , V > next;
int expectedModCount;
int index;
Entry < K , V > current;
HashIterator ( ) {
expectedModCount = modCount;
if ( size > 0 ) {
Entry [ ] t = table;
while ( index < t. length && ( next = t[ index++ ] ) == null )
;
}
}
public final boolean hasNext ( ) {
return next != null ;
}
final Entry < K , V > nextEntry ( ) {
if ( modCount != expectedModCount)
throw new ConcurrentModificationException ( ) ;
Entry < K , V > e = next;
if ( e == null )
throw new NoSuchElementException ( ) ;
if ( ( next = e. next) == null ) {
Entry [ ] t = table;
while ( index < t. length && ( next = t[ index++ ] ) == null )
;
}
current = e;
return e;
}
public void remove ( ) {
if ( current == null )
throw new IllegalStateException ( ) ;
if ( modCount != expectedModCount)
throw new ConcurrentModificationException ( ) ;
Object k = current. key;
current = null ;
HashMap . this . removeEntryForKey ( k) ;
expectedModCount = modCount;
}
}