Eine Art Ranking

[gauo]

Hallo,
Ich habe versucht eine Art Ranking zu realisieren.
Die Idee, ich habe einige Keys die Values haben nach denen sie Sortiert werden.
Ich will diese Values aktualisieren können und dann die ersten n geliefert bekommen können.

Leider bekomm ich bei

Map.Entry entry = (Map.Entry)(set.last());

einen Nullpoint und ich raff net ganz
wieso, aber wahrscheinlich hab ich einfach etwas elementares nicht geschnallt :/

bitte hilft mir und danke das ihr überhaupt so weit gelesen habt ^^.

import java.util.*;
import java.lang.reflect.Array;
public class Ranking<E,B extends Comparable[B]>
{
    TreeMap<E,B> map= new TreeMap<E,B>();
    /**
     * Constructor for objects of class Ranking
     */
    public Ranking()
    {

    }
    public void put(E key,B value){
        map.put(key,value);
        System.out.println(map.get(key));
    }
    public B get(E key){
        return map.get(key);
    }
    public Vector<E> getFirstN(int n){
        Vector<E> values= new Vector<E>();

    TreeSet set = new TreeSet(new Comparator() {
            public int compare(Object obj, Object obj1) {
                return ((Comparable) ((Map.Entry) obj).getValue()).compareTo(((Map.Entry) obj1).getValue());
            }
        });
    set.addAll(map.entrySet());
    for(int i=0;i<n;i++){
        Map.Entry entry = (Map.Entry)(set.last());
        set.remove(entry);
        values.add((E)entry.getValue());
    }
    return values;
    }
    
}

 

[Marco13]

// Von [url]http://www.java-forum.org/de/viewtopic.php?t=68740&highlight=&sid=9c54636410b3aaec19f9128722eba2a6[/url]
import java.util.*;
import java.lang.reflect.Array;
public class Ranking<E,B extends Comparable[B]>
{
    public static void main(String args[])
    {
        Ranking<String, Integer> r = new Ranking<String, Integer>();
        r.put("Eins", 1);
        r.put("Drei", 3);
        r.put("AuchDrei", 3);
        r.put("Zwei", 2);

        System.out.println(r.getFirstN(2));
    }



    TreeMap<E,B> map= new TreeMap<E,B>();
    /**
     * Constructor for objects of class Ranking
     */
    public Ranking()
    {

    }
    public void put(E key,B value){
        map.put(key,value);
        System.out.println(map.get(key));
    }
    public B get(E key){
        return map.get(key);
    }
    public Vector<E> getFirstN(int n){
        Vector<E> values= new Vector<E>();

    TreeSet set = new TreeSet(new Comparator() {
            public int compare(Object obj, Object obj1) {
                return ((Comparable) ((Map.Entry) obj).getValue()).compareTo(((Map.Entry) obj1).getValue());
            }
        });
    set.addAll(map.entrySet());
    for(int i=0;i<n;i++){
        Map.Entry entry = (Map.Entry)(set.last());
        set.remove(entry);
        values.add((E)entry.getValue());
    }
    return values;
    }

}

Ausgabe:

1
3
3
2
[3, 2]

... und wie soll es sein?

 

[Guest]

-.- hab einen fehler endeckt,
ich brauche die Keys dann zurück statt der Values....
aber ne andere frage, weshalb hast du nur 1mal die 3?
aber mit

values.add((E)entry.getValue());

wirft es mit immer noch an der Stelle

Map.Entry entry = (Map.Entry)(set.last());

im Ranking einen Nullpointer, no such Element

hier mal die Klasse in der ich das Ranking benutz...ganz unten in der Methode tillMillions

public class Lotto
{
    Wuerfel wuerfel= new Wuerfel();
    int[] zahlenDerZiehung6of49 = new int[6];
    int zusatzzahl;
    /**
     * Constructor for objects of class Lotto
     */
    public Lotto()
    {

    }
    /**
     * Zieht 6 aus 49 und achtet dabei darauf das keine bereits gezogen wurde.
     */
    public void draw6of49(){
        reset();
        for(int i=0;i<6;i++){
            zahlenDerZiehung6of49[i]=drawTillHasNotBeenDrawn(49);
        }
        
    }
    /**
     * Zieht die Zusatzzahl und achtet darauf das diese noch nicht gezogen wurde.
     */
    public void drawZusatzzahl(){
      zusatzzahl = drawTillHasNotBeenDrawn(49);
    }
    /**
     * Methode aus d)
     */
    public void lottozahlenZiehen(){
           draw6of49();
           drawZusatzzahl();
           showLottozahlen();
    }
    /**
     * Setzt den Speicher fuer die Zieheung zurueck.
     */
    public void reset(){
        zahlenDerZiehung6of49 = new int[6];
    }
    /**
     * Zieht solange zahlen von [1,range], bis eine zurueck gegeb wird, 
     * die noch nicht unter den Gewinnzahlen enthalten ist.
     * @param range aus der die Ziehbaren gezogen werden sollen.
     * @return Naechste gezogene Zahl.
     */
    public int drawTillHasNotBeenDrawn(int range){
        int digit=wuerfel.wurf(range);
        for(;hasBeenDrawn(digit);digit=wuerfel.wurf(range));
        return digit;
    }
    /**
     * Überprüft ob die Zahl bereits gezogen wurde.
     * @param digit Zahl die zu überprüfen ist.
     * @return ob diese Zahl entahlten ist.
     */
    public boolean hasBeenDrawn(int digit){
    for(int i=0;i<zahlenDerZiehung6of49.length;i++){
        if(zahlenDerZiehung6of49[i]==digit){
            return true;}
        }
        return false;
    }
    /**
     * Gibt die gezogenen Zahlen aus.
     */
    public void showLottozahlen(){
        System.out.println();
        System.out.print("Die Lottozahlen");
        for(int i=0;i<6;i++){
            System.out.print(":"+zahlenDerZiehung6of49[i]);
        }
        System.out.println();
        System.out.println(" Zusatzzahl:"+zusatzzahl);
    }
 // ab hier sind nur spielereien.   
    public void testLotto(int anzahl){
        int[] zahlen = new int[49];
        float erwartung =((100/49)+(100/48)+(100/47)+(100/46)+(100/45)+(100/44));
        for(int i=0;i<anzahl;i++){
            draw6of49();
            for(int k=0;k<6;k++){
             zahlen[zahlenDerZiehung6of49[k]-1]+=1;
            }
        }
        for(int i=0;i<49;i++){
        System.out.println("Die Zahl "+(i+1)+" wurde "+zahlen[i]+"-mal gezogen:"+(zahlen[i]*100)/anzahl+"% :Erwartet "+erwartung+"%");
        }
    }
    
    public void tillMillions(int schritte){
        Ranking<Integer,Integer> ranking= new Ranking<Integer,Integer>();
        for(int i=1;i<=49;i++){
        ranking.put(i,1);
        }
        draw6of49();
        int steps=0;
        for(Vector<Integer> numbers=ranking.getFirstN(6);(!six(numbers))&&(steps<schritte);numbers=ranking.getFirstN(6)){
            for(int i=0;i<6;i++){
                int digit=zahlenDerZiehung6of49[i];
                int newNumberOfTimesDrawn =ranking.get(zahlenDerZiehung6of49[i])+1;
                ranking.put(digit,newNumberOfTimesDrawn);
                draw6of49();
                steps++;
            }
        }
        
        
    }

    public boolean six(Vector<Integer> numbers){
    return (hasBeenDrawn(numbers.get(0))&&
            hasBeenDrawn(numbers.get(1))&&
            hasBeenDrawn(numbers.get(2))&&
            hasBeenDrawn(numbers.get(3))&&
            hasBeenDrawn(numbers.get(4))&&
            hasBeenDrawn(numbers.get(5)));
        }
}

 

[Marco13]

Ja, wenn der Set leer ist, und man ruft set.last() auf, passiert das eben. Das ganze Programm ist halt ziemlich chaotisch und ... teilweise ... hm ... suboptimal, aber zum Rumprobieren... naja.

Irgendwie habe ich jetzt das Gefühl, es könnte helfen, mal das hier http://www.java-forum.org/de/viewtopic.php?p=410214 zu posten. Ansonsten solltest du genauer sagen, was du willst....

 

[gauo]

:/ ich schnall aber nicht ganz weshalb es leer sein sollte,
ich fülle es doch mit

        Ranking<Integer,Integer> ranking= new Ranking<Integer,Integer>();
        for(int i=1;i<=49;i++){
        ranking.put(i,1);
        }

Meine rumprobiererrei war eigentlich so gedacht, dass ich mir immer merke welche zahlen bisher wie oft gezogen wurden, und für meinen nächsten tipp die top 6 nehme, solange bis ich 6 richtige hab oder halt diese maximale schritte erreicht hab...ich weiß theoretisch sollten sinds immer die selben wahrscheinlichkeiten aber ...naja ^^

 

[Marco13]

Der Set wird leer, weil er nur einen Eintrag enthält, und der beim ersten Schleifendurchlauf entfernt wird. Der Comparator, den du beim TreeSet angibst, sorgt dafür, dass zwei Einträge mit gleichen Values als gleich angesehen werden. D.h. wenn du zwei Entries (123,4) und (567,4) hast, werden die als gleich angesehen und nur einer bleibt in der Map. Ggf. solltest du die Elemente nicht in einen TreeSet einfügen, sondern in eine List, und die dann mit
Collections.sort(list, comparator);
sortieren - der Comparator kann dann der sein, den du bisher für den TreeSet verwendest.

Das Rumprobieren ist ja OK. Nur sollte man bedenken, dass solche Zeilen wie
for(Vector<Integer> numbers=ranking.getFirstN(6);(!six(numbers))&&(steps<schritte);numbers=ranking.getFirstN(6)){
eher ungünstig sind ... bei jedem Durchlauf wird da allein für den Schleifenkopf SEHR viel gerechnet (und ganz allgemein ist eben vieles ziemlich unperformant implementiert).