Mega Code Archive
Bucketized Hashtable
<![CDATA[
/*
* The contents of this file are subject to the terms
* of the Common Development and Distribution License
* (the "License"). You may not use this file except
* in compliance with the License.
*
* You can obtain a copy of the license at
* glassfish/bootstrap/legal/CDDLv1.0.txt or
* https://glassfish.dev.java.net/public/CDDLv1.0.html.
* See the License for the specific language governing
* permissions and limitations under the License.
*
* When distributing Covered Code, include this CDDL
* HEADER in each file and include the License file at
* glassfish/bootstrap/legal/CDDLv1.0.txt. If applicable,
* add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your
* own identifying information: Portions Copyright [yyyy]
* [name of copyright owner]
*/
import java.io.Serializable;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* This class implements bucketize hashtable, which subdivide the key collection
* stored into several hashtables (buckets) of smaller size. This will reduce
* the contention of hashtable.
* @author Shing Wai Chan
*/
public class BucketizedHashtable implements Cloneable, Map, Serializable {
private int bucketSize;
private Hashtable[] hashtables = null;
/**
* Constructs a new, empty BucketizedHashtable with the specified bucket
* size, initial capacity and load factor.
* @param bucketSize the number of buckets used for hashing
* @param initialCapacity the initial capacity of BucketizedHashtable
* @param loadFactor the load factor of hashtable
*/
public BucketizedHashtable(int bucketSize, int initialCapacity,
float loadFactor) {
if (bucketSize <= 0 || initialCapacity < 0) {
throw new IllegalArgumentException();
}
this.bucketSize = bucketSize;
hashtables = new Hashtable[bucketSize];
// always round up to the nearest integer so that it has at
// least the initialCapacity
int initialHashtableSize = (int) Math.ceil(
(double) initialCapacity / bucketSize);
for (int i = 0; i < bucketSize; i++) {
hashtables[i] = new Hashtable(initialHashtableSize, loadFactor);
}
}
/**
* Constructs a new, empty BucketizedHashtable with the specified bucket
* size, initial capacity and default load factor 0.75.
* @param bucketSize the number of buckets used for hashing
* @param initialCapacity the initial capacity of hashtable
*/
public BucketizedHashtable(int bucketSize, int initialCapacity) {
this(bucketSize, initialCapacity, 0.75f);
}
/**
* Constructs a new, empty BucketizedHashtable with the specified bucket
* size, default initial capacity (11 * bucketSize) and default load factor
* 0.75.
* @param bucketSize the number of buckets used for hashing
*/
public BucketizedHashtable(int bucketSize) {
this(bucketSize, 11 * bucketSize, 0.75f);
}
/**
* Constructs a new, empty BucketizedHashtable with the default bucket size
* 11, default initial capacity (11 * bucketSize) and default load factor
* 0.75.
* @param bucketSize the number of buckets used for hashing
*/
public BucketizedHashtable() {
this(11, 11 * 11, 0.75f);
}
//-------- implementing Map --------
/**
* @param key a key in the hashtable
* @return the value to which the specified key is mapped.
*/
public Object get(Object key) {
return hashtables[getBucketIndex(key)].get(key);
}
/**
* Remove the key and its corresponding value.
* @param key the key that needs to be removed
* @return the value to which the key had been mapped, or <code>null</code>
* if the key did not have a mapping.
*/
public Object remove(Object key) {
return hashtables[getBucketIndex(key)].remove(key);
}
/**
* Maps the specified <code>key</code> to the specified <code>value</code>
* in this hashtable. Neither the key nor the value can be
* <code>null</code>. <p>
* @param key the hashtable key
* @param value the value
* @return the previous value of the specified key in hashtables, or
* <code>null</code> if it did not have one.
*/
public Object put(Object key, Object value) {
return hashtables[getBucketIndex(key)].put(key, value);
}
/**
* @param t BucketizedHashtable or a Map with a supported operation
* entrySet
*/
public void putAll(Map t) {
if (t instanceof BucketizedHashtable) {
BucketizedHashtable bt = (BucketizedHashtable) t;
for (int i = 0; i < bt.bucketSize; i++) {
putAllFromMapWithEntrySet(bt.hashtables[i]);
}
} else {
putAllFromMapWithEntrySet(t);
}
}
/**
* @param key possible key
* @return true if and only if the specified object is a key in one of of
* the hashtables
*/
public boolean containsKey(Object key) {
return hashtables[getBucketIndex(key)].containsKey(key);
}
/**
* @param value possible value
* @return true if and only if the specified object is a value in one of of
* the hashtables
*/
public boolean containsValue(Object value) {
for (int i = 0; i < bucketSize; i++) {
if (hashtables[i].containsValue(value)) {
return true;
}
}
return false;
}
/**
* @return the total number of key-value mappings of all buckets
*/
public int size() {
int totalSize = 0;
for (int i = 0; i < bucketSize; i++) {
totalSize += hashtables[i].size();
}
return totalSize;
}
/**
* @return the hash code value for this map
*/
public int hashCode() {
int h = 0;
for (int i = 0; i < bucketSize; i++) {
h += hashtables[i].hashCode();
}
return h;
}
/**
* @return true if this map contains no key-value mappings
*/
public boolean isEmpty() {
for (int i = 0; i < bucketSize; i++) {
if (!hashtables[i].isEmpty()) {
return false;
}
}
return true;
}
/**
* Clears this BucketizedHashtable so that it contains no key.
*/
public void clear() {
for (int i = 0; i < bucketSize; i++) {
hashtables[i].clear();
}
}
/**
* The return set is backed by the map, so changes to the map are reflected
* in the set, and vice-versa.
* @return a set of Map.Entry when bucketSet equal 1
* @throws UnsupportedOperationException when bucketSize is greater one
*/
public Set entrySet() {
if (bucketSize == 1) {
return hashtables[0].entrySet();
} else {
throw new UnsupportedOperationException();
}
}
/**
* The return set is backed by the map, so changes to the map are reflected
* in the set, and vice-versa.
* @return a set of keys when bucketSet equal 1
* @throws UnsupportedOperationException when bucketSize is greater one
*/
public Set keySet() {
if (bucketSize == 1) {
return hashtables[0].keySet();
} else {
throw new UnsupportedOperationException();
}
}
/**
* The return collection is backed by the map, so changes to the map are
* reflected in the collection, and vice-versa.
* @return a collection of values when bucketSet equal 1
* @throws UnsupportedOperationException when bucketSize is greater one
*/
public Collection values() {
if (bucketSize == 1) {
return hashtables[0].values();
} else {
throw new UnsupportedOperationException();
}
}
/**
* Compares the specified object with this map for equality.
* @return true if the specified object is a BucketizedHashtable with
* hashtables represent the same set of mappings.
*/
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof BucketizedHashtable)) {
return false;
}
BucketizedHashtable bt = (BucketizedHashtable) o;
if (bt.bucketSize != bucketSize || bt.size() != size()) {
return false;
}
for (int i = 0; i < bucketSize; i++) {
if (!hashtables[i].equals(bt.hashtables[i])) {
return false;
}
}
return true;
}
//-------- implementing Cloneable --------
/**
* Creates and returns a shallow copy of this object. The keys and values
* are not cloned.
* @return a clone of BucketizedHashtable
*/
public Object clone() {
try {
BucketizedHashtable bt = (BucketizedHashtable) super.clone();
bt.bucketSize = bucketSize;
bt.hashtables = new Hashtable[bucketSize];
for (int i = 0; i < bucketSize; i++) {
bt.hashtables[i] = (Hashtable) hashtables[i].clone();
}
return bt;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
//----------------
/**
* @return a string representation of this BucketizedHashtable
*/
public String toString() {
StringBuffer buf = new StringBuffer("["); // NOI18N
//bucketSize always >= 1
buf.append(hashtables[0].toString());
for (int i = 1; i < bucketSize; i++) {
buf.append(", "); // NOI18N
buf.append(hashtables[i].toString());
}
buf.append("]"); // NOI18N
return buf.toString();
}
/**
* @param t Map with a supported entrySet operation
*/
private void putAllFromMapWithEntrySet(Map t) {
Iterator iter = t.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry e = (Map.Entry) iter.next();
put(e.getKey(), e.getValue());
}
}
/**
* @param key
* @return the bucket index for the specified key
*/
private int getBucketIndex(Object key) {
int index = key.hashCode() % bucketSize;
return (index >= 0) ? index : index + bucketSize;
}
}
]]>