| Methods Summary |
|---|
| public synchronized void | clear()Removes all of the mappings from this IdentityHashtable.
if (count > 0) {
Entry[] copyOfEntries = entries;
for (int i = copyOfEntries.length; --i >= 0;) {
copyOfEntries[i] = null;
}
count = 0;
}
|
| public synchronized java.lang.Object | clone()Returns a shallow copy of this IdentityHashtable (the
elements are not cloned).
try {
Entry[] copyOfEntries = entries;
IdentityHashtable clone = (IdentityHashtable)super.clone();
clone.entries = new Entry[copyOfEntries.length];
for (int i = copyOfEntries.length; i-- > 0;) {
clone.entries[i] = (copyOfEntries[i] != null) ? (Entry)copyOfEntries[i].clone() : null;
}
return clone;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
|
| public synchronized boolean | contains(java.lang.Object obj)Returns true if this IdentityHashtable contains
the given object. Equality is tested by the equals() method.
if (obj == null) {
throw new NullPointerException();
}
Entry[] copyOfEntries = entries;
for (int i = copyOfEntries.length; i-- > 0;) {
for (Entry e = copyOfEntries[i]; e != null; e = e.next) {
if (e.value.equals(obj)) {
return true;
}
}
}
return false;
|
| public synchronized boolean | containsKey(java.lang.Object key)Returns true if this IdentityHashtable contains a
mapping for the given key. Equality is tested by reference.
Entry[] copyOfEntries = entries;
int hash = System.identityHashCode(key);
int index = (hash & 0x7FFFFFFF) % copyOfEntries.length;
for (Entry e = copyOfEntries[index]; e != null; e = e.next) {
if (e.key == key) {
return true;
}
}
return false;
|
| public synchronized java.util.Enumeration | elements()
if (count == 0) {
return emptyEnumerator;
} else {
return new Enumerator(ELEMENTS);
}
|
| public synchronized java.lang.Object | get(java.lang.Object key)Returns the value to which the given key is mapped in this
IdentityHashtable. Returns null if this
IdentityHashtable contains no mapping for this key.
Entry[] copyOfEntries = entries;
int hash = System.identityHashCode(key);
int index = (hash & 0x7FFFFFFF) % copyOfEntries.length;
for (Entry e = copyOfEntries[index]; e != null; e = e.next) {
if (e.key == key) {
return e.value;
}
}
return null;
|
| public boolean | isEmpty()
return (count == 0);
|
| public synchronized java.util.Enumeration | keys()
if (count == 0) {
return emptyEnumerator;
} else {
return new Enumerator(KEYS);
}
|
| public synchronized java.lang.Object | put(java.lang.Object key, java.lang.Object obj)Associate the given object with the given key in this
IdentityHashtable, replacing any existing mapping.
if (obj == null) {
throw new NullPointerException();
}
Entry[] copyOfEntries = entries;
int hash = System.identityHashCode(key);
int index = (hash & 0x7FFFFFFF) % copyOfEntries.length;
for (Entry e = copyOfEntries[index]; e != null; e = e.next) {
if (e.key == key) {
Object old = e.value;
e.value = obj;
return old;
}
}
if (count >= threshold) {
rehash();
copyOfEntries = entries;
index = (hash & 0x7FFFFFFF) % copyOfEntries.length;
}
Entry e = new Entry(hash, key, obj, copyOfEntries[index]);
copyOfEntries[index] = e;
count++;
return null;
|
| private void | readObject(java.io.ObjectInputStream s)Deserialize the IdentityHashtable from a stream.
// Read in the threshold, loadfactor (and any hidden 'magic' stuff).
s.defaultReadObject();
// Read in number of buckets and allocate the bucket array;
int numBuckets = s.readInt();
entries = new Entry[numBuckets];
// Read in size (count)
int size = s.readInt();
// Read the mappings and add to the TopLinkIdentityHashMap
for (int i = 0; i < size; i++) {
Object key = s.readObject();
Object value = s.readObject();
put(key, value);
}
|
| private void | rehash()INTERNAL:
Re-builds the internal array of Entry's with a larger capacity.
This method is called automatically when the number of objects in this
IdentityHashtable exceeds its current threshold.
int oldCapacity = entries.length;
Entry[] oldEntries = entries;
int newCapacity = (oldCapacity * 2) + 1;
Entry[] newEntries = new Entry[newCapacity];
threshold = (int)(newCapacity * loadFactor);
entries = newEntries;
for (int i = oldCapacity; i-- > 0;) {
for (Entry old = oldEntries[i]; old != null;) {
Entry e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = newEntries[index];
newEntries[index] = e;
}
}
|
| public synchronized java.lang.Object | remove(java.lang.Object key)Removes the mapping (key and its corresponding value) from this
IdentityHashtable, if present.
Entry[] copyOfEntries = entries;
int hash = System.identityHashCode(key);
int index = (hash & 0x7FFFFFFF) % copyOfEntries.length;
for (Entry e = copyOfEntries[index], prev = null; e != null; prev = e, e = e.next) {
if (e.key == key) {
if (prev != null) {
prev.next = e.next;
} else {
copyOfEntries[index] = e.next;
}
count--;
return e.value;
}
}
return null;
|
| public int | size()
return count;
|
| public synchronized java.lang.String | toString()Return the string representation of this IdentityHashtable.
int max = size() - 1;
StringBuffer buf = new StringBuffer();
Enumeration k = keys();
Enumeration e = elements();
buf.append("{");
for (int i = 0; i <= max; i++) {
String s1 = k.nextElement().toString();
String s2 = e.nextElement().toString();
buf.append(s1 + "=" + s2);
if (i < max) {
buf.append(", ");
}
}
buf.append("}");
return buf.toString();
|
| private void | writeObject(java.io.ObjectOutputStream s)Serialize the state of this IdentityHashtable to a stream.
// Write out the threshold, loadfactor (and any hidden 'magic' stuff).
s.defaultWriteObject();
// Write out number of buckets
s.writeInt(entries.length);
// Write out count
s.writeInt(count);
// Write out contents
for (int i = entries.length - 1; i >= 0; i--) {
Entry entry = entries[i];
while (entry != null) {
s.writeObject(entry.key);
s.writeObject(entry.value);
entry = entry.next;
}
}
|
