Strings aus einer ArrayList zählen

[Xendran]

Hallo!
Ich habe folgendes Problem:
Ich habe eine ArrayList<String> und möchte mit Hilfe einer HashMap<String, Integer> zählen, wie oft die einzelnen Strings in der Liste vorkommen. Wie schaffe ich es, dass der int Wert hochgezählt wird?

MfG,
Xendran

 

[The_S]

int counter = 0;
// in der schleife
counter++;

 

[Xendran]

Hm, vielleicht hab ich mich falsch ausgedrückt, denn so wird ja nur gezählt, wie viele Strings insgesamt vorkommen, ich will aber wissen, wie oft die einzelnen Strings vorkommen, wenn sie denn häufiger vorkommen.
Also, sagen wir bspw. ich hab in der Liste 5 * "e" 2und 3 * "a". In der HashMap will ich also als Key e und als Value 5 haben.
So hab ichs bisher:

public static HashMap<String, Integer> statistik() {
		HashMap<String, Integer> hash = new HashMap<String, Integer>();
		ArrayList<String> ar = new ArrayList<String>();
		ar = /*bla bla, meine Liste halt*/
		for (int i = 0; i < ar.size(); i++) {
			hash.put(ar.get(i), /*keine Ahnung*/);
		}
		return hash;
	}

 

[SlaterB]

anzahl = map.getZuWort
if anzahl null
   anzahl = 1
else
   anzahl = anzahl +1

map speichere wort + anzahl

 

[Murray]

Etwa so:

ArrayList<String> lstStr = ...;
HashMap<String,Integer> map = new HashMap<String,Integer>();
for ( String str : lstStr) {
    Integer i = map.get( str);
    if ( i == null) {
        //--- noch nicht in der Liste -> jetzt also einmal vorhanden
        i = new Integer( 1);
    } else {
        //--- Anzahl um 1 erhoehen
        i = new Integer( i.intValue()+1);
    }
    map.put( str, i);
}
for ( String key : map.keySet()) {
    System.out.println( key + ": " + map.get( key));
}

 

[Xendran]

Danke, das hat mir erstmal ein bisschen weiter geholfen, auch wenn ichs noch nicht ganz funktionierend hingekriegt habe.

 

[SlaterB]

viele new Integer( 1) -Objekte lassen sich vermeiden
-> Integer.valueOf(1)

geht für alle Zahlen bis 128 daher auch für den else-Fall geeignet,
bei höheren Zahlen macht valueOf letztlich auch ein new Integer()

 

[Leroy42]

viele new Integer( 1) -Objekte lassen sich vermeiden
-> Integer.valueOf(1)

geht für alle Zahlen bis 128 daher auch für den else-Fall geeignet,
bei höheren Zahlen macht valueOf letztlich auch ein new Integer()

Jein! Auch new Integer(n) nutzt für kleine n den internen Pool
==> Es macht keinen Unterschied.

 

[Marco13]

Nur aus Neugier: Was veranlaßt dich zu dieser aussage?

   /**
     * Constructs a newly allocated <code>Integer</code> object that
     * represents the specified <code>int</code> value.
     *
     * @param   value   the value to be represented by the 
     *			<code>Integer</code> object.
     */
    public Integer(int value) {
	this.value = value;
    }

new heißt new - ich denke, da ist nichts mit einem Pool.

   /**
     * Returns a <tt>Integer</tt> instance representing the specified
     * <tt>int</tt> value.
     * If a new <tt>Integer</tt> instance is not required, this method
     * should generally be used in preference to the constructor
     * {@link #Integer(int)}, as this method is likely to yield
     * significantly better space and time performance by caching
     * frequently requested values.
     *
     * @param  i an <code>int</code> value.
     * @return a <tt>Integer</tt> instance representing <tt>i</tt>.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
	final int offset = 128;
	if (i >= -128 && i <= 127) { // must cache 
	    return IntegerCache.cache[i + offset];
	}
        return new Integer(i);
    }

Was mich irritert ist, dass dort von performancegewinnen bei "häufig verwendeten Werten" die Rede ist - dort aber offenbar nur bestimmte (kleine) Werte gecacht werden... ???:L

 

[SlaterB]

wie man an obiger Anwendung sieht sind da die kleinen Zahlen doch offensichtlich die richtigen
wenns drauf ankommt einfach selber ein Array anlegen

@Leroy:
bei mir nicht ;(

public class Test
{


    public static void main(String[] args)
        throws Exception

    {
        int anz = 80000000;
        long time = 0;

        time = System.currentTimeMillis();
        for (int i=0; i<anz; i++) {
            new Integer(1556);
        }
        System.out.println("time: "+(System.currentTimeMillis()-time));

        time = System.currentTimeMillis();
        for (int i=0; i<anz; i++) {
            new Integer(1);
        }
        System.out.println("time: "+(System.currentTimeMillis()-time));
        time = System.currentTimeMillis();
        for (int i=0; i<anz; i++) {
            Integer.valueOf(1);
        }
        System.out.println("time: "+(System.currentTimeMillis()-time));
        


    }


}

->
time: 1297
time: 1265
time: 204

 

[The_S]

Das ist doch mal was für die Performance-Ecke!

public class Test
{


    public static void main(String[] args)
        throws Exception

    {
        int anz = 80000000;
        long time = 0;

        time = System.currentTimeMillis();
        for (int i=0; i<anz; i++) {
            new Integer(1556);
        }
        System.out.println("time: "+(System.currentTimeMillis()-time));

        time = System.currentTimeMillis();
        for (int i=0; i<anz; i++) {
            new Integer(1);
        }
        System.out.println("time: "+(System.currentTimeMillis()-time));
        time = System.currentTimeMillis();
        for (int i=0; i<anz; i++) {
            Integer.valueOf(1);
        }
        System.out.println("time: "+(System.currentTimeMillis()-time));
        


    }


}

->
time: 1297
time: 1265
time: 204

:applaus: :toll:

 

[Leroy42]

Jein! Auch new Integer(n) nutzt für kleine n den internen Pool
==> Es macht keinen Unterschied.

Marco13 und SlaterB haben natürlich Recht.
Ich weiß auch nicht, wo ich meinte das mal in
den Sourcen gesehen zu haben.

Am peinlichsten ist jedoch, das ich nicht darauf gekommen bin,
das es (in Java) gar nicht funktionieren kann, daß ein
Konstruktor eine andere Instanz liefert.

In die Ecke gehen und mich schämen, mache ich allerdings jetzt
nicht, da ich, in weiser Voraussicht( ), micht bereits gestern
vormittag selbst gegeißelt habe.