Begrenzung der maximalen Größe einer HashMap in Java

Möchte ich begrenzen die maximale Größe einer HashMap zu nehmen Metriken, die auf eine Vielzahl von hashing-algorithmen, dass ich die Umsetzung. Ich schaute auf die loadfactor in einem HashMap's überladenen Konstruktoren.

HashMap(int initialCapacity, float loadFactor)

Ich habe versucht Einstellung der loadFactor, 0.0 f in den Konstruktor (was bedeutet, dass ich nicht wollen, dass die HashMap, in der Größe wachsen auch IMMER) aber javac nennt diese ungültig:

Exception in thread "main" java.lang.IllegalArgumentException: Illegal load factor: 0.0
        at java.util.HashMap.<init>(HashMap.java:177)
        at hashtables.CustomHash.<init>(Main.java:20)
        at hashtables.Main.main(Main.java:70) Java Result: 1

Gibt es eine andere Möglichkeit der Begrenzung der Größe von HashMap so dass es nicht immer?

InformationsquelleAutor der Frage andandandand | 2011-04-08

hashmap java

Manchmal einfacher ist besser.

public class InstrumentedHashMap<K, V> implements Map<K, V> {

    private Map<K, V> map;

    public InstrumentedHashMap() {
        map = new HashMap<K, V>();
    }

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

    ...
}

InformationsquelleAutor der Antwort Mike

Könnte man eine neue Klasse erstellen, wie dies zum begrenzen der Größe einer HashMap:

public class MaxSizeHashMap<K, V> extends LinkedHashMap<K, V> {
    private final int maxSize;

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

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

InformationsquelleAutor der Antwort WhiteFang34

6

Einfache Lösung ist meist die beste, so verwenden Sie unmodifiable oder Unveränderlich hashmap.

Wenn Sie nicht ändern können Menge von Elementen, dann ist die Größe behoben werden - problem gelöst.

InformationsquelleAutor der Antwort Margus

public class Cache {
    private LinkedHashMap<String, String> Cache = null;
    private final int cacheSize;  
    private ReadWriteLock readWriteLock=null;
    public Cache(LinkedHashMap<String, String> 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<String, String> getCache() {
        return Cache;
    }

    public void setCache(
            LinkedHashMap<String, String> Cache) {
        this.Cache = Cache;
    }


}

InformationsquelleAutor der Antwort Kanagavelu Sugumar

Die Methode put in die HashMap-Klasse ist die, die verantwortlich für das hinzufügen der Elemente in der HashMap und er tut es durch den Aufruf einer Methode mit dem Namen addEntry welcher code ist wie folgt:

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

Wie Sie sehen können, die in dieser Methode wird die HashMap wird verändert, wenn der Schwellenwert überschritten worden ist, so würde ich versuchen, erweitern Sie die Klasse HashMap und Schreibe meine eigenen Methoden für put und addEntry um entfernen Sie die Größenänderung. So etwas wie:

package java.util;

public class MyHashMap<K, V> extends HashMap {


    private V myPutForNullKey(V value) {
        for (Entry<K, V> 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 < table.length) { 
            int hash = hash(key.hashCode());
            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++;
            myAddEntry(hash, key, value, i);
        }
        return null;
    }

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

Würden Sie brauchen, um schreiben Sie Ihre eigenen Methoden, da put und addEntry nicht überschreiben, und Sie würden auch brauchen, um das gleiche zu tun für putForNullKey da wird aufgerufen, in put. Eine Validierung in put ist erforderlich, um sicherzustellen, dass wir nicht versuchen, ein Objekt, wenn die Tabelle voll ist.

InformationsquelleAutor der Antwort Maricel

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.