[Java] tellertje bijhouden in een Collection

[brama]

Ik heb een Map van String naar Integer. Die Integer is in principe een tellertje die ik regelmatig wil ophogen. De huidige methode doet zoiets:

Java:

Integer count = map.get(key);
count = new Integer(count.intValue() + 1);
map.put(key, count);

Niet bijzonder efficient, zullen we maar zeggen..

De oplossing (versimpelde weergave) die ik voor ogen heb is:

Java:

public class Counter {
  public Counter(int fInitVal) {
    this.value = fInitVal;
  }

  public int getValue() {
    return this.value;
  }

  public void increase(int fIncreaseVal)  {
    this.value += fIncreaseVal;
  }

  private int value;
}

//..

Counter c = map.get(key);
c.increase(1);

Nou zal dit wel goed werken, maar ik vraag me af of ik niet een veel voor de hand ligggender oplossing mis waarbij ik niet zelf die Counter class hoef te maken?

[pjvandesande]

Java kent toch wel zo iets als:

Java:

count++;

[Nick_S]

questa schreef op woensdag 11 januari 2006 @ 16:57:
Java kent toch wel zo iets als:

Java:

count++;

Helaas werkt dat alleen op de primitieve int en niet op het object Integer. Als je met Java 5 werkt, zou je echter door de autoboxing volgens mij wel op het object Integer de ++ operator aan kunnen roepen.

Met eerdere java versies zul je inderdaad een eigen Counter klasse aan moeten maken of met nieuwe Integers werken. De eerste daarvan heeft voor mij de voorkeur, hoe minder instanties van objecten je aan hoeft te maken hoe beter.

_{Brama, over je posts hieronder, wil je de volgende keer gebruik maken van de edit knop ipv 2 berichten?}

[ Voor 9% gewijzigd door Nick_S op 11-01-2006 17:16 ]

[sys64738]

Waarom wil je uberhaupt een Integer die als teller fungeert in een Map opslaan? Je kunt die teller toch ook in een losse int bijhouden (naast je map)? Of heb je iets heel moois bedacht waardoor dit niet zo makkelijk gaat?

[ Voor 4% gewijzigd door sys64738 op 11-01-2006 17:04 ]

[brama]

Nick_S schreef op woensdag 11 januari 2006 @ 17:01:
[...]


Helaas werkt dat alleen op de primitieve int en niet op het object Integer. Als je met Java 5 werkt, zou je echter door de autoboxing volgens mij wel op het object Integer de ++ operator aan kunnen roepen.

Met eerdere java versies zul je inderdaad een eigen Counter klasse aan moeten maken of met nieuwe Integers werken. De eerste daarvan heeft voor mij de voorkeur, hoe minder instanties van objecten je aan hoeft te maken hoe beter.

Ah, dat autoboxing is een nuttige tip. Ik gebruik inderdaad java 1.5, maar die nieuwe feature heb ik nog niet onderzocht. Dat zal ik bij deze eens gaan doen

[brama]

sys64738 schreef op woensdag 11 januari 2006 @ 17:03:
Waarom wil je uberhaupt een Integer die als teller fungeert in een Map opslaan? Je kunt die teller toch ook in een losse int bijhouden (naast je map)? Of heb je iets heel moois bedacht waardoor dit niet zo makkelijk gaat?

Ik wil juist een mapping bijhouden van woord naar aantal voorkomens. Dus per key een tellertje.

[DaCoTa]

Nick_S schreef op woensdag 11 januari 2006 @ 17:01:
[...]
Helaas werkt dat alleen op de primitieve int en niet op het object Integer. Als je met Java 5 werkt, zou je echter door de autoboxing volgens mij wel op het object Integer de ++ operator aan kunnen roepen.

Met eerdere java versies zul je inderdaad een eigen Counter klasse aan moeten maken of met nieuwe Integers werken. De eerste daarvan heeft voor mij de voorkeur, hoe minder instanties van objecten je aan hoeft te maken hoe beter.

Het autoboxing is qua implementatie identiek aan een nieuw Integer object aanmaken per mutatie, dus als je veel te tellen hebt, is dat niet echt efficient. Een eigen class object als wrapper om een int heen, desnoods final en zo veel mogelijk methods static is qua geheugengebruik echt niet inefficienter vergeleken met allemaal nieuwe Integer objecten aanmaken. Ook al worden Integer objecten - dacht ik - tegenwoordig gepooled en evt. hergebruikt, zou het me niks verbazen als je eigen Counter class efficienter is.

Wijsheid in deze is om een kleine benchmark te schrijven en het gewoon even te testen, alle code heb je in principe al.

[.oisyn]

Nick_S schreef op woensdag 11 januari 2006 @ 17:01:

Helaas werkt dat alleen op de primitieve int en niet op het object Integer. Als je met Java 5 werkt, zou je echter door de autoboxing volgens mij wel op het object Integer de ++ operator aan kunnen roepen.

Nee, een Integer object is immutable. Je kunt 'm dus niet ophogen, je kunt slechts de waarde uitlezen. Iets als map.put(map.get(key) + 1) zal dus wel werken, maar dat maakt het niet minder efficient dan de code van de topicstarter.

[Varienaja]

Die oplossing met de Counter-class gaat gewoon goed werken.

Als je nog veel meer rauwe snelheid nodig hebt, dan denk ik dat je het beste een eigen Map-implementatie maakt:

De originele versie staat hieronder.

code:

    /**
     * Associates the specified value with the specified key in this map.
     * If the map previously contained a mapping for this key, the old
     * value is replaced.
     *
     * @param key key with which the specified value is to be associated.
     * @param value value to be associated with the specified key.
     * @return previous value associated with specified key, or <tt>null</tt>
     *         if there was no mapping for key.  A <tt>null</tt> return can
     *         also indicate that the HashMap previously associated
     *         <tt>null</tt> with the specified key.
     */
    public V put(K key, V value) {
    K k = maskNull(key);
        int hash = hash(k);
        int i = indexFor(hash, table.length);

        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            if (e.hash == hash && eq(k, e.key)) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, k, value, i);
        return null;
    }

Als je nu de regel e.value = value vervangt door e.value++ oid ben je al klaar.

[brama]

Okay, lijkt me duidelijk dat ik niets over het hoofd gezien heb en dat die Counter implementatie inderdaad "the way to go" is. Dat het efficienter is dan oplossingen waarbij continu Integer objecten aangemaakt en opgeruimd worden lijkt me evident.

Bedankt voor de feedback.