[Java] Sorteren van ArrayList

[Verwijderd]

Hallo Mensen,

Ik ben op dit moment bezig voor een schoolopdracht. De opdracht is om het spelletje LunarLockout te maken. Het spel gaat tot nu toe aardig maar ik zit nu al 2 dagen vast op het maken van mijn highscorelijstje.

De spelernamen met de scores heb ik opgeslagen in een arraylist.
Het is dus nu de bedoeling dat de arraylist gesorteerd word op score van hoog naar laag.

Ik heb het voor elkaar gekregen om de arraylist uit te lezen en ze te tonen op het scherm.

Het lijkt mij dat ik daar iets aan toe moet voegen om ervoor te zorgen dat hij ze gesorteerd op het scherm laat zien. De code voor de topscore ziet er als volgt uit:

code:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Collections;
import java.util.Comparator; 
import java.util.List;
import java.util.ArrayList;

public class TopScore extends Panel {
    private int x, y;
    private JLabel labelq;
    private LunarLockout ll;
    private SpelBeheerder lijst;
    
    private ArrayList scoreArray;

    private Color achtergrondBlauw = new Color(116, 142, 160, 255);

    public TopScore(int x, int y, LunarLockout ll) {
        this.x = x;
        this.y = y;
        this.ll = ll;
        this.setBounds(x, y, 668, 450);

        setLayout(null);
        labelq = new JLabel("Sluiten", JLabel.CENTER);
        labelq.setBounds(280, 400, 100, 30);
        labelq.addMouseListener(new MuisHandler());
        labelq.setForeground(Color.BLACK);
        labelq.setFont(new Font("Manga Temple", Font.PLAIN, 18));
        labelq.setOpaque(false);
        //Collections.sort(this.scoreArray, Collections.reverseOrder());

        add(labelq);
    }

    public void paint(Graphics g) {
        AntiAlias.setAntiAlias(g, true);

        g.setColor(achtergrondBlauw);
        g.fillRect(0, 0, 668, 450);

        g.setColor(Color.BLACK);
        g.drawRect(0, 0, 667, 449);

        g.setFont(new Font("Manga Temple", Font.PLAIN, 25));
        g.setColor(Color.black);
        g.drawString("Topscore:", 250, 40);
        
        for (int i = 0; i < scoreArray.size() && i < 10; i++) {
            Speler dezeSpeler = (Speler) scoreArray.get(i);
            
            int posY = 80 + (i * 28);
            g.drawString(dezeSpeler.getNaam(), 150, posY);
            g.drawString(Integer.toString(dezeSpeler.getScore()), 400, posY);
            
        }       
        super.paint(g);
    }
    
    public void setScoreArray(ArrayList sa) {
        this.scoreArray = sa;
    }


    class MuisHandler extends MouseAdapter {
        public void mousePressed(MouseEvent e) {
            if (e.isMetaDown()) // rechts klikken
            {
            } else if (e.isAltDown()) // midden muis knop
            {
            } else // links klikken
            {
                if (e.getClickCount() == 2) // dubbelclick
                {
                } else // geen dubbelclick
                {
                    ll.removeTopScore();
                    ll.showHoofdmenu();
                }
            }
        }
    }
}

Kan iemand mij assjeblieft helpen deze arraylist te sorteren?

[TheRookie]

je zal het array moeten sorteren voordat je 'm weer gaat geven; zo te zien heb je al een poging gewaagd (r 32) ?

Java:

Collections.sort(this.scoreArray, Collections.reverseOrder());

[ Voor 12% gewijzigd door TheRookie op 20-01-2006 16:01 . Reden: code erbij ]

[momania]

Je moet zorgen dat de objecten die je erin propt de interface Comparable implementeren.

Je object krijgt dan een "int compareTo(Object o)" method waarin je je score kan vergelijken en dus een -1, 0 of 1 terug geven.

Voor meer info:
http://java.sun.com/j2se/...html#sort(java.util.List)
http://java.sun.com/j2se/...java/lang/Comparable.html

[.oisyn]

@momania: als dat zinnig is voor dat type iig, en dat lijkt me nou net niet voor een generiek object als een Speler (natuurlijk wil je in dit verband sorteren op score, maar wil je Spelers altijd zo sorteren?). Anders kun je ook een Comparator implementeren en die meegeven aan de sort functie.

[ Voor 20% gewijzigd door .oisyn op 20-01-2006 16:09 ]

[Nick_S]

Je zou dan bij die sort methode een Comparator kunnen opgeven, die bij de methode

Java:

public int compare(Object o1, Object o2);

-1 terug geeft als Speler1 een lagere score heeft als Speler2
0 terug geeft als Speler1 een gelijke score heeft als Speler2
1 terug geeft als Speler1 een hogere score heeft als Speler2

Voor meer informatie, zie Collections.sort en de Comparator interface.

[edit: Ik moet sneller typen of een origineel antwoord verzinnen]

[ Voor 6% gewijzigd door Nick_S op 20-01-2006 16:10 ]

[momania]

.oisyn schreef op vrijdag 20 januari 2006 @ 16:08:
@momania: als dat zinnig is voor dat type iig, en dat lijkt me nou net niet voor een generiek object als een Speler (natuurlijk wil je in dit verband sorteren op score, maar wil je Spelers altijd zo sorteren?). Anders kun je ook een Comparator implementeren en die meegeven aan de sort functie.

Een Comarator maken kan idd ook. Dan kan je voor verschillende sorteringen verschillende Comparator implementaties maken.

't is maar net of je meer dan 1 sorteerd methode nodig hebt

Gebruik je er maar 1 dan kan je net zo goed Comparable implementeren en ze in een TreeSet stoppen oid, dan is het altijd direct gesorteerd

[.oisyn]

Mijn punt was meer dat je een type alleen een Comparable moet laten implementeren als er een natural ordering voor dat type bestaat. Stel je maakt je eigen Integer class, of iets als een Date. Die types impliceren dat je ze kunt vergelijken en dat er een bepaalde ordering bestaat. Maar voor iets als een Speler is dat helemaal niet zo logisch, waarom zou een Speler met een hogere score vóór een speler met een lagere score moeten komen? Waarom gaat dat bv. niet op alfabet?

Bij het implementeren van de scorelijst blijkt idd dat je een lijst van Spelers moet sorteren, maar dat betekent niet dat je dan maar de Speler class aan moet passen zodat ie een Comparable implementeert die sorteert op score. Wellicht wil je later de spelers ook eens sorteren op naam, wat dan? Nogmaals een Comparable implementeren kan natuurlijk niet, en dan kun je wel speciaal voor die gelegenheid alsnog een Comparator maken die sorteert op naam, maar waarom is die sorteer-methode minder "belangrijk" dan sorteren op score? Waarom verdient sorteren op score wel een Comparable interface in Speler, en sorteren op naam niet?

Zoals ik het zie verdienen ze het allebei niet, de ene speler is niet automatisch meer of minder dan de andere speler. Het Speler type is niet iets dat een bepaalde ordering suggereert. En dus implementeer je geen Comparable maar een Comparator

[ Voor 3% gewijzigd door .oisyn op 20-01-2006 16:23 ]

[momania]

.oisyn schreef op vrijdag 20 januari 2006 @ 16:22:

Zoals ik het zie verdienen ze het allebei niet, de ene speler is niet automatisch meer of minder dan de andere speler. En dus implementeer je geen Comparable maar een Comparator

Ah zo

Idd, je hebt helemaal gelijk.

Zelf in het vervolg ook maar meer op letten, aangezien ik volgens mij veel te vaan uit gemakzucht Comparable implementeer.

[Verwijderd]

Ok bedankt voor de reacties maar ben bang dat het boven mijn pet gaat .

Het gaat alleen om het uitlezen van de score en de naam, ik heb gelezen dat je een arraylist ook kan converteren naar een array en deze dan kunt tonen op het scherm.

of is dat zonde van de tijd?

[momania]

Als je nou voor deze regel:

Java:

for (int i = 0; i < scoreArray.size() && i < 10; i++) {

dit doet:

Java:

Collections.sort(scoreArray, new TopScoreComparator())

Dan moet je alleen nog een TopScoreComparator maken.

iets als:

Java:

public class TopScoreComparator implements Comparator {
  public int compare(Object o1, Object o1) {
    // vergelijk hier je twee Speler objecten...
  }
}

Zo moet je wel een heel eind verder komen denk ik

[edit]
En lees ook goed javadocs door van de dingen die je nodig hebt
http://java.sun.com/j2se/...java/util/Comparator.html

[ Voor 15% gewijzigd door momania op 20-01-2006 16:49 ]

[Verwijderd]

Bedankt ! Ik ga even zoeken ! Laat straks even weten of het is gelukt ...

[Verwijderd]

Ik heb bij deze momania HEILIG verklaard !!!!

thx !!!

het werkt !!!

De rest natuurlijk ook bedankt voor de reacties !!!
Zie hier de code:

code:

Collections.sort(scoreArray, Collections.reverseOrder(new TopScoreComparator()));

public class TopScoreComparator implements Comparator 
{
          public int compare(Object o1, Object o2) 
          {
              return ( ((Speler)o1).getScore() - ((Speler)o2).getScore() );
             //vergelijk hier je twee Speler objecten...
          }
}

[ Voor 58% gewijzigd door Verwijderd op 21-01-2006 14:03 ]

[Swinnio]

even nog voor de volledigheid: zou het niet netter zijn de TopScoreComparator een private inner class van Speler te maken? Hij heeft immers geen zinvolle betekenis buiten die klasse....

[Swinnio]

Verwijderd schreef op zaterdag 21 januari 2006 @ 14:01:
Ik heb bij deze momania HEILIG verklaard !!!!

thx !!!

het werkt !!!

De rest natuurlijk ook bedankt voor de reacties !!!
Zie hier de code:

code:

Collections.sort(scoreArray, Collections.reverseOrder(new TopScoreComparator()));

public class TopScoreComparator implements Comparator 
{
          public int compare(Object o1, Object o2) 
          {
              return ( ((Speler)o1).getScore() - ((Speler)o2).getScore() );
             //vergelijk hier je twee Speler objecten...
          }
}

Dit werkt inderdaad, maar beter lijkt me om -1, 0 of 1 terug te geven. Zo dus:

Java:

public int compare(Object o1, Object o2) 
 {
     if (((Speler)01).getScore() < ((Speler)o2).getScore())) return -1;
     if (((Speler)01).getScore() == ((Speler)o2).getScore())) return 0;
     return 1;
 }

[ Voor 6% gewijzigd door Swinnio op 22-01-2006 15:21 ]

[Robtimus]

Waarom?
Van de Java API van Comparable.compareTo:

Returns:
a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

Java kijkt zelf ook alleen maar of de return waarde 0, < 0 of > 0 is. Dan is de beide scores van elkaar aftrekken ook prima.

Let er trouwens wel op als je met longs gaat rekenen - als de waarde niet in een int zou passen en je cast het toch expliciet naar een int* dan wordt het deel dat niet in de int past genegeerd. Het resultaat kan dan negatief zijn als int zelfs al is het positief als long.

*

Java:

return (int)(long1 - long2);