public StaticBucketMap() 
{
                   
        this(DEFAULT_BUCKETS);
}

Initializes the map with the default number of buckets (255).

 public StaticBucketMap(int numBuckets) 
{
        int size = Math.max(17, numBuckets);
        // Ensure that bucketSize is never a power of 2 (to ensure maximal distribution)
        if (size % 2 == 0) {
            size--;
        }
        buckets = new Node[size];
        locks = new Lock[size];
        for (int i = 0; i <  size; i++) {
            locks[i] = new Lock();
        }
}

Initializes the map with a specified number of buckets. The number of buckets is never below 17, and is always an odd number (StaticBucketMap ensures this). The number of buckets is inversely proportional to the chances for thread contention. The fewer buckets, the more chances for thread contention. The more buckets the fewer chances for thread contention.

Parameters:

numBuckets - the number of buckets for this map

 public  void atomic(Runnable r) 
{
        if (r == null) throw new NullPointerException();
        atomic(r, 0);
}

Prevents any operations from occurring on this map while the given Runnable executes. This method can be used, for instance, to execute a bulk operation atomically:

staticBucketMapInstance.atomic(new Runnable() {
public void run() {
staticBucketMapInstance.putAll(map);
}
});

It can also be used if you need a reliable iterator:

staticBucketMapInstance.atomic(new Runnable() {
public void run() {
Iterator iterator = staticBucketMapInstance.iterator();
while (iterator.hasNext()) {
foo(iterator.next();
}
}
});

Implementation note: This method requires a lot of time and a ton of stack space. Essentially a recursive algorithm is used to enter each bucket's monitor. If you have twenty thousand buckets in your map, then the recursive method will be invoked twenty thousand times. You have been warned.

 public  void clear() 
{
        for (int i = 0; i <  buckets.length; i++) {
            Lock lock = locks[i];
            synchronized (lock) {
                buckets[i] = null;
                lock.size = 0;
            }
        }
}

Clears the map of all entries.

 public boolean containsKey(Object key) 
{
        int hash = getHash(key);
        synchronized (locks[hash]) {
            Node n = buckets[hash];
            while (n != null) {
                if (n.key == key || (n.key != null && n.key.equals(key))) {
                    return true;
                }
                n = n.next;
            }
        }
        return false;
}

Checks if the map contains the specified key.

 public boolean containsValue(Object value) 
{
        for (int i = 0; i <  buckets.length; i++) {
            synchronized (locks[i]) {
                Node n = buckets[i];
                while (n != null) {
                    if (n.value == value || (n.value != null && n.value.equals(value))) {
                        return true;
                    }
                    n = n.next;
                }
            }
        }
        return false;
}

Checks if the map contains the specified value.

 public Set entrySet() 
{
        return new EntrySet();
}

Gets the entry set.

 public boolean equals(Object obj) 
{
        if (obj == this) {
            return true;
        }
        if (obj instanceof Map == false) {
            return false;
        }
        Map other = (Map) obj;
        return entrySet().equals(other.entrySet());
}

Compares this map to another, as per the Map specification.

 public Object get(Object key) 
{
        int hash = getHash(key);
        synchronized (locks[hash]) {
            Node n = buckets[hash];
            while (n != null) {
                if (n.key == key || (n.key != null && n.key.equals(key))) {
                    return n.value;
                }
                n = n.next;
            }
        }
        return null;
}

Gets the value associated with the key.

 public int hashCode() 
{
        int hashCode = 0;
        for (int i = 0; i <  buckets.length; i++) {
            synchronized (locks[i]) {
                Node n = buckets[i];
                while (n != null) {
                    hashCode += n.hashCode();
                    n = n.next;
                }
            }
        }
        return hashCode;
}

Gets the hash code, as per the Map specification.

 public boolean isEmpty() 
{
        return (size() == 0);
}

Checks if the size is currently zero.

 public Set keySet() 
{
        return new KeySet();
}

Gets the key set.

 public Object put(Object key,
    Object value) 
{
        int hash = getHash(key);
        synchronized (locks[hash]) {
            Node n = buckets[hash];
            if (n == null) {
                n = new Node();
                n.key = key;
                n.value = value;
                buckets[hash] = n;
                locks[hash].size++;
                return null;
            }
            // Set n to the last node in the linked list.  Check each key along the way
            //  If the key is found, then change the value of that node and return
            //  the old value.
            for (Node next = n; next != null; next = next.next) {
                n = next;
                if (n.key == key || (n.key != null && n.key.equals(key))) {
                    Object returnVal = n.value;
                    n.value = value;
                    return returnVal;
                }
            }
            // The key was not found in the current list of nodes, add it to the end
            //  in a new node.
            Node newNode = new Node();
            newNode.key = key;
            newNode.value = value;
            n.next = newNode;
            locks[hash].size++;
        }
        return null;
}

Puts a new key value mapping into the map.

 public  void putAll(Map map) 
{
        Iterator i = map.keySet().iterator();
        while (i.hasNext()) {
            Object key = i.next();
            put(key, map.get(key));
        }
}

Puts all the entries from the specified map into this map. This operation is not atomic and may have undesired effects.

 public Object remove(Object key) 
{
        int hash = getHash(key);
        synchronized (locks[hash]) {
            Node n = buckets[hash];
            Node prev = null;
            while (n != null) {
                if (n.key == key || (n.key != null && n.key.equals(key))) {
                    // Remove this node from the linked list of nodes.
                    if (null == prev) {
                        // This node was the head, set the next node to be the new head.
                        buckets[hash] = n.next;
                    } else {
                        // Set the next node of the previous node to be the node after this one.
                        prev.next = n.next;
                    }
                    locks[hash].size--;
                    return n.value;
                }
                prev = n;
                n = n.next;
            }
        }
        return null;
}

Removes the specified key from the map.

 public int size() 
{
        int cnt = 0;
        for (int i = 0; i <  buckets.length; i++) {
            cnt += locks[i].size;
        }
        return cnt;
}

Gets the current size of the map. The value is computed fresh each time the method is called.

 public Collection values() 
{
        return new Values();
}

Gets the values.