Java HashMap sortieren nach Häufigkeit

[BingoXL]

Hallo Zusammen,

ich suche eine Lösung, wie ich eine vorhandene HashMap<String, Integer> nicht nach dem Schlüssel (String) sortieren... sondern nach dem Integerwert sortieren kann.

Klar ist mir, dass ich aus der HashMap eine Liste (LinkedList)bauen muss... mit Collections.sort(liste) kann ich aber nur nach den Schlüsseln sortieren!

Hier mein Programm, passend zu Fußball WM:

import java.util.*;
import java.util.HashMap;
public class Uebung_Map 
{

	public static void main(String[] args)
	{
		//Tabelle anlegen und füllen
		HashMap<String, Integer> table = new HashMap<String, Integer>();
		
		table.put("Mueller",1);
		table.put("Torres",5);
		table.put("Villa",3);
		table.put("Vittec",4);
		//Tabelle ausgeben
		for(String a : table.keySet())
			System.out.println(a + " mit sovielen Toren: " + table.get(a));
		
		//In Liste umwandeln
		List<String> hilf = new LinkedList<String>();
		for (String key : table.keySet())
			hilf.add(key);
		//Liste Sortieren
		Collections.sort(hilf);
		//Sortiere Liste ausgeben
		for(String s : hilf)
			System.out.println(s+ " => "+table.get(s));			
	}
}

Jetzt würde ich gerne die Tabelle nach der Anzahl der Tore sortieren...
Wie gehe ich nun weiter vor? Würde mich über eine Lösung freuen!

Grüße
BingoXL

 

[RolloFy]

http://stackoverflow.com/questions/109383/how-to-sort-a-mapkey-value-on-the-values-in-java

Erster Treffer bei http://www.google.de/search?hl=de&q=java sort map by values

 

[kinglouy]

Eine (simple) Möglichkeit wäre eine Art Selectionsort.
Du hast deine Liste mit den Namen der Spieler (die Keys), diese müsstest du also durchlaufen und für jeden Spieler nachgucken, wieviele Tore er hat. Den Spieler mit den meisten Toren gibst du aus und löscht ihn aus der Liste der Keys.
Das musst du solange wiederholen, bis die Liste leer ist.
Die Lösung ist nicht besonders effektiv, aber funktioniert.

Eine andere Möglichkeit wäre, dass du die Keys nicht in eine Liste einträgst, sondern
einen Heap verwendest, an dessen Wurzel sich immer das kleinste Element befindet (also der Spieler mit den wenigsten Toren).
Das wäre eine aufsteigende Sortierung und du willst aber wahrscheinlich eine Absteigende. Ich glaube für solche Zwecke kann man bei Java (lang ists her) einen Comperator übergeben,
wodurch du die Heapordnung selbst bestimmen kannst.

 

[Soultaker]

Sowas würde auch gehen, hast aber dann keine schicke HashMap mehr

public static void main(final String[] args) {
        final List<PlayerStat> test = new LinkedList<PlayerStat>();
        test.add( new PlayerStat( "Mueller", 1 ) );
        test.add( new PlayerStat( "Torres", 5 ) );
        test.add( new PlayerStat( "Villa", 3 ) );
        test.add( new PlayerStat( "Vittec", 4 ) );

        Collections.sort( test, new Comparator<PlayerStat>() {

            public int compare(final PlayerStat o1, final PlayerStat o2) {
                if( o1.numberOfGoals > o2.numberOfGoals ) return 1;
                return 0;

            }

        } );

        for( final PlayerStat s : test ) {
            System.out.println( s.name + " => " + s.numberOfGoals );
        }
        System.out.println( "-----------" );

        Collections.sort( test, new Comparator<PlayerStat>() {

            public int compare(final PlayerStat o1, final PlayerStat o2) {
                return o1.name.compareTo( o2.name );

            }

        } );

        for( final PlayerStat s : test ) {
            System.out.println( s.name + " => " + s.numberOfGoals );
        }

    }

    static class PlayerStat {
        private final String name;
        private final int    numberOfGoals;

        public PlayerStat(final String name, final int numberOfGoals) {
            this.name = name;
            this.numberOfGoals = numberOfGoals;
        }
    }

 

[samotyr]

Ich würde eine andere Herangehensweise empfehlen:

Erzeugung einer Klasse Spieler:

public class Player implements Comparable<Player>{
  private String name;
  private int goals;
  (...)

  public String getName() (...)
  public int getGoals() (...)

  @Override
  public int compareTo(Player o){
    // TODO hier die beiden Objekte vergleichen, siehe Dokumentation
    return 0;
  }
}

Das Objekt kannst du nun in einer Liste oder einem Set verwenden und über die Collections API sortieren lassen. Musst nur darauf achten bei der Verwendung von Sets auch equals() und hashCode() zu überschreiben.

Man kann die Comparatoren übrigens auch austauschen, Collections.sort() bietet hierfür statische Methoden an.

Nachtrag:
Oh, ich sehe erst jetzt, dass mein Vorredner quasi das gleiche gepostet hat. Naja, jetzt hab ich schon so viel getippt, dann poste ich das auch

 

[BingoXL]

Hallo Zusammen...

Vielen Dank für eure Lösungsvorschläge!
@Soultaker genau sowas habe ich gesucht... Wusste nicht, dass es unter Collections.sort geht, mit Comperator zu suchen!

Merci auch an alle anderen...