在Java中限制HashMap的最大大小。-LimitingthemaxsizeofaHashMapinJava

30  

Sometimes simpler is better.

有时越简单越好。

public class InstrumentedHashMap implements Map {

    private Map map;

    public InstrumentedHashMap() {
        map = new HashMap();
    }

    public boolean put(K key, V value) {
        if (map.size() >= MAX && !map.containsKey(key)) {
             return false;
        } else {
             map.put(...);
             return true;
        }
    }

    ...
}

91  

You could create a new class like this to limit the size of a HashMap:

您可以创建这样的新类来限制HashMap的大小:

public class MaxSizeHashMap extends LinkedHashMap {
    private final int maxSize;

    public MaxSizeHashMap(int maxSize) {
        this.maxSize = maxSize;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > maxSize;
    }
}

6  

Simple solution is usually the best, so use unmodifiable or Immutable hashmap.

简单的解决方案通常是最好的，所以使用不可修改的或不可变的hashmap。

If you can not change amount of elements, then the size will be fixed - problem solved.

如果你不能改变元素的数量，那么大小将是固定的-问题解决了。

2  

public class Cache {
    private LinkedHashMap Cache = null;
    private final int cacheSize;  
    private ReadWriteLock readWriteLock=null;
    public Cache(LinkedHashMap psCacheMap, int size) {
        this.Cache = psCacheMap;
        cacheSize = size;
        readWriteLock=new ReentrantReadWriteLock();
    }

    public void put(String sql, String pstmt) throws SQLException{
        if(Cache.size() >= cacheSize && cacheSize > 0){
            String oldStmt=null;
            String oldSql = Cache.keySet().iterator().next();
            oldStmt = remove(oldSql);
            oldStmt.inCache(false);
            oldStmt.close();

        }
        Cache.put(sql, pstmt);
    }

    public String get(String sql){
        Lock readLock=readWriteLock.readLock();
        try{
            readLock.lock();
            return Cache.get(sql);
        }finally{
            readLock.unlock();
        }
    }

    public boolean containsKey(String sql){
        Lock readLock=readWriteLock.readLock();
        try{
            readLock.lock();
            return Cache.containsKey(sql);
        }finally{
            readLock.unlock();
        }
    }

    public String remove(String key){
        Lock writeLock=readWriteLock.writeLock();
        try{
            writeLock.lock();
            return Cache.remove(key);
        }finally{
            writeLock.unlock();
        }
    }

    public LinkedHashMap getCache() {
        return Cache;
    }

    public void setCache(
            LinkedHashMap Cache) {
        this.Cache = Cache;
    }


}

1  

The method put in the HashMap class is the one in charge of adding the elements into the HashMap and it does it by calling a method named addEntry which code is as follows:

HashMap类中的方法是负责将元素添加到HashMap中的方法，它通过调用一个名为addEntry的方法来实现它，该方法代码如下:

   void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry e = table[bucketIndex];
        table[bucketIndex] = new Entry(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    } 

As you can see in this method is where the HashMap is resized if the threshold has been exceeded, so I would try extending the class HashMap and writing my own methods for put and addEntry in order to remove the resizing. Something like:

正如您在这个方法中看到的，如果阈值已经超过了，HashMap将被调整大小，所以我将尝试扩展类HashMap并编写自己的put和addEntry方法，以删除调整大小。喜欢的东西:

package java.util;

public class MyHashMap extends HashMap {


    private V myPutForNullKey(V value) {
        for (Entry e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        myAddEntry(0, null, value, 0);
        return null;
    }

    public V myPut(K key, V value) {
        if (key == null)
            return myPutForNullKey(value);
        if (size  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++;
            myAddEntry(hash, key, value, i);
        }
        return null;
    }

    void myAddEntry(int hash, K key, V value, int bucketIndex) {
        Entry e = table[bucketIndex];
        table[bucketIndex] = new Entry(hash, key, value, e);
        size++;
    }
}

You would need to write your own methods since put and addEntry cannot be overriding and you would also need to do the same for putForNullKey since it is called inside put. A validation in put is required to verify that we are not trying to put an object if the table is full.

您需要编写自己的方法，因为put和addEntry不能重写，而且您还需要对putForNullKey执行相同的操作，因为它被称为inside put。put的验证需要验证，如果表已经满了，我们不会尝试放入一个对象。