Gleiche Werte aus Array aussortieren

[LittleKing205]

Guten Abend,

ich habe gerade ein Problem mit meinem Array aus Player Objekten mit dem jeweiligen score Werten.
Am ende eines Spiels möchte ich nun eine Auswertung haben wer auf welchem Platz ist. Aber Spieler mit gleichen Punktzahlen müssen noch mal Stechen um deren Platz auszuloten.
Aus diesem Grund muss ich die Gleichpunktiereten Spieler nacheinander antren lassen.
Nur habe ich keine Ahnung, wie ich dieses Array so zerflücke, dass ich gleiche Werte auslese.

 

[Xyz1]

Am Besten du sammelst alle Matches in einem extra Array. Zum Bleistift alle Player, die 40 Punkte haben müssen jeweils zwei gegeneinander "antreten".

 

[LittleKing205]

Es sollten alle Spieler gleichzeitig angezeigt werden. Damit alle um die reihenfolge Spielen können.
Bsp. (die Ausgabe, die ich bekomme wenn ich die Spieler der Punkte nach Sortiert hole)
10.12.2017 18:26:32 [Info] 1. Spieler 1 (5 Pkt.)
10.12.2017 18:26:32 [Info] 2. Spieler 4 (4 Pkt.)
10.12.2017 18:26:32 [Info] 3. Spieler 3 (4 Pkt.)
10.12.2017 18:26:32 [Info] 4. Spieler 2 (4 Pkt.)
10.12.2017 18:26:32 [Info] 5. Spieler 5 (2 Pkt.)

Dort bräuchte müsste ich nur noch die Spieler 4,3,2 in einem Array, damit ich die danach neu in diese Liste einsortieren kann.

Die Folgende Funktion wird aufgerufen, wenn das Spiel zuende ist.

    public void endGame() {
       turnier.frameControler.showDialog("Letztes Spiel zu Ende.\nAuswertung beginnt");
       Player[] p = getPlayer(Player.SORT_BY_SCORE);
      
       // Stechen

       //Platzierungen anzeigen
       String list = "";
       int platz = 1;
       Logger.log("Platzierungen:");
       for(Player pl : Player.sort(getPlayer(), Player.SORT_BY_SCORE)) {
           list = list + platz + ". " + pl.getName() + " (" + pl.getScore() + " Pkt.)\n";
           Logger.log(platz + ". " + pl.getName() + " (" + pl.getScore() + " Pkt.)");
           platz++;
       }
       turnier.frameControler.showDialog(list);
   }

 

[Xyz1]

Damit es sinn macht:

class Player implements Comparable<Player> {
    int score = 0;
    Player(int score) {
        this.score = score;
    }
    @Override
    public int compareTo(Player o) {
        return o.score - this.score;
    }
    public static void main(String[] args) {
        Player[] plays = new Player[]{
            new Player(0),
            new Player(40),
            new Player(40),
            new Player(40),
            new Player(40),
            new Player(60),
            new Player(60),
            new Player(17)
        };
        Arrays.sort(plays);

        Player[][] same = new Player[0][0];
        Player[][][] matches = new Player[0][0][0];
        for (int i = 0; i < plays.length;) {
            Player[] a = new Player[0];
            int j = i;
            for (; j < plays.length - 1 && plays[j].score == plays[j + 1].score; j++) {
                Player[] b = new Player[a.length + 1];
                System.arraycopy(a, 0, b, 0, a.length);
                b[a.length] = plays[j];
                a = b;
            }
            if (j != i) {
                Player[] b = new Player[a.length + 1];
                System.arraycopy(a, 0, b, 0, a.length);
                b[a.length] = plays[j];
                a = b;

                Player[][] c = new Player[same.length + 1][];
                System.arraycopy(same, 0, c, 0, same.length);
                c[same.length] = a;
                same = c;
            }
            i = j + 1;
        }
        for (int i = 0; i < same.length; i++) {
            Player[][] a = new Player[0][0];
            for (int j = 0; j < same[i].length; j++) {
                for (int k = j + 1; k < same[i].length; k++) {
                    Player[][] b = new Player[a.length + 1][];
                    System.arraycopy(a, 0, b, 0, a.length);
                    b[a.length] = new Player[]{same[i][j], same[i][k]};
                    a = b;
                }
            }
            Player[][][] c = new Player[matches.length + 1][][];
            System.arraycopy(matches, 0, c, 0, matches.length);
            c[matches.length] = a;
            matches = c;
        }

        for (int i = 0; i < matches.length; i++) {
            System.out.println("Match Gruppe: " + (i + 1));
            for (int j = 0; j < matches[i].length; j++) {
                System.out.println("Match zwischen: " + Arrays.toString(matches[i][j]));
            }
        }
    }
}

Matches:

Match Gruppe: 1
Match zwischen: [Player@1, Player@2]
Match Gruppe: 2
Match zwischen: [Player@3, Player@4]
Match zwischen: [Player@3, Player@5]
Match zwischen: [Player@3, Player@6]
Match zwischen: [Player@4, Player@5]
Match zwischen: [Player@4, Player@6]
Match zwischen: [Player@5, Player@6]

Aber du solltest dringend höherwertige Kontainer benutzen.

 

[LittleKing205]

Entschuldige, dass ich erstmal nicht online war.
Kannst du mir ein wenig den sehr komplexen Code erklären? Damit das auch richtig einsetzen kann?
Das wäre sehr nett.

 

[Xyz1]

gern, drei Schleifen, die ich mal "Hauptschritte" nenne:
Players mit gleichem Score finden
für jede Gruppe mit gleichem Score jeden gegen jeden antreten lassen
alle Gruppen und Matches ausgeben lassen

Das ganze ist so boilerplate, weils nicht Arrays mit Arrays gleicher Länge sind, die Länge unbestimmt ist und weil es mit "höherwertigen" Containern viel komfortabler wäre.