[Java] Array met objecten sorteren.

[Verwijderd]

Ik heb een array die bestaat uit objecten. Elke regel bestaat uit een club
met daarachter de stand. Dit staat allemaal door elkaar. Nu wil ik deze
array sorteren. De club met de meeste punten bovenaan etc. Mocht het
aantal punten gelijk zijn dan moet weer worden gekeken naar het doelsaldo.
Hoe kan ik dit realiseren ?

[whoami]

Ik weet niet hoe het in Java precies ziet met die 'collection' classes enzo, maar heeft een Vector oid geen 'Sort' method oid?

In C# heb je een arraylist, en die heeft een member method 'Sort'. Om die te kunnen gebruiken, moeten de objecten die je in de ArrayList gepropt hebt wel de interface IComparable implementeren.
Ik denk dat dat in Java op ongeveer dezelfde manier ook wel mogelijk moet zijn.

[Glimi]

Dit is op te lossen dmv het implementeren van een Comperator of in je classes de interface Comperator te implementeren.
De array is dan dmv Arrays.sort( Object[] ) of dmv Arrays.sort( Object[], Comperator) te sorteren

[Verwijderd]

Hij wil toch op waardes in het object sorteren? Of kan dit dan met de hierboven genoemde oplossing ?

[whoami]

Verwijderd schreef op 05 December 2002 @ 11:17:
Hij wil toch op waardes in het object sorteren? Of kan dit dan met de hierboven genoemde oplossing ?

Ja, je moet gewoon in je comparetor opgeven hoe er moet gesorteerd worden.
Je bepaald gewoon welk veld er moet gebruikt worden om op te sorteren en je kan ook aangeven of er aflopend/oplopend moet gesorteerd worden.

[Verwijderd]

Oke , ik moet dus import java.util.* doen en dan gaat het om het volgende :

/**
* Sorts the specified array of objects according to the order induced by
* the specified comparator. All elements in the array must be
* <i>mutually comparable</i> by the specified comparator (that is,
* <tt>c.compare(e1, e2)</tt> must not throw a <tt>ClassCastException</tt>
* for any elements <tt>e1</tt> and <tt>e2</tt> in the array).<p>
*
* This sort is guaranteed to be <i>stable</i>: equal elements will
* not be reordered as a result of the sort.<p>
*
* The sorting algorithm is a modified mergesort (in which the merge is
* omitted if the highest element in the low sublist is less than the
* lowest element in the high sublist). This algorithm offers guaranteed
* n*log(n) performance, and can approach linear performance on nearly
* sorted lists.
*
* @param a the array to be sorted.
* @param c the comparator to determine the order of the array. A
* <tt>null</tt> value indicates that the elements' <i>natural
* ordering</i> should be used.
* @throws ClassCastException if the array contains elements that are
* not <i>mutually comparable</i> using the specified comparator.
* @see Comparator
*/
public static void sort(Object[] a, Comparator c) {
Object aux[] = (Object[])a.clone();
if (c==null)
mergeSort(aux, a, 0, a.length);
else
mergeSort(aux, a, 0, a.length, c);
}

Het ziet er als volgt uit bij mij :
compStand[a] = club , gespeeld, gewonnen, gelijk, verloren, punten, dpv, dpt

compStand[0] = ajax, 2 , 2 , 0, 0, 6, 3 , 1
compStand[1] = mvv, 1 , 0 , 1 , 0, 1, 0, 0
compstand[2] = psv, 2 , 0, 1 , 1, 1 , 1, 3

Hoe komt dat er dan uit te zien ?
En hoe krijg ik ze terug ?

[Soultaker]

Verwijderd schreef op 05 December 2002 @ 11:37:
Het ziet er als volgt uit bij mij :
compStand[a] = club , gespeeld, gewonnen, gelijk, verloren, punten, dpv, dpt

compStand[0] = ajax, 2 , 2 , 0, 0, 6, 3 , 1
compStand[1] = mvv, 1 , 0 , 1 , 0, 1, 0, 0
compstand[2] = psv, 2 , 0, 1 , 1, 1 , 1, 3

Hoe komt dat er dan uit te zien ?
En hoe krijg ik ze terug ?

Wat heb je zelf al bedacht en geprobeerd? Heb je al een Comperator klasse of Comparable interface geïmplementeert, zoals Glimi en whoami suggereerden?

[ Voor 1% gewijzigd door Soultaker op 05-12-2002 11:42 . Reden: credit to whoami ]

[Verwijderd]

Nee nog niet. Ik weet niet precies hoe ik het moet aanpakken. Ik wou kijken welke het grootst was en dan wegschrijven naar een file maar dat is onbegonnen werk.

[whoami]

Je maakt een class Ploeg oid.
Die class bevat een aantal members:
naam, punten, wedstrijden gewonnen, gespeeld, ....

Objecten van die class voeg je toe aan die Vector. Je gaat die Vector gaan sorteren mbhv een Comperator.

[Verwijderd]

Een vector is toch hetzelfde als een Array waarvan je de grootte niet weet ?
Ik heb de hele verwerking al klaar. Alleen moet hij de boel sorteren.

[whoami]

Verwijderd schreef op 05 December 2002 @ 11:58:
Een vector is toch hetzelfde als een Array waarvan je de grootte niet weet ?
Ik heb de hele verwerking al klaar. Alleen moet hij de boel sorteren.

Niet helemaal.
Een vector zal wel een array gebruiken om de gegevens in op te slaan, maar een vector biedt nog een aantal extra functionaliteiten, zoals sorteren, item inserten, item removen, item adden, 'growen', ...

[Bobco]

Een Vector is wat handiger, juist omdat je de grootte niet van tevoren vast hoeft te leggen. Sorteren is ook makkelijker. Het enige wat je hoeft te doen is de Vector in een SortedSet stoppen en de SortedSet sorteert de object gebaseerd op hun natural order. Deze ordening kun je zelf aangeven door de Comparable interface te implementeren in de Ploeg class die whoami noemde. Je hoeft dan alleen nog maar de SortedSet te doorlopen en je hebt alles keurig in volgorde staan.

Zelf ben ik niet zo wild van arrays omdat deze nogal statisch zijn. Collections zijn veel handiger om mee te werken en geven je veel functionaliteit cadeau.

[Verwijderd]

Ik zie het niet meer. Weet dat het niet mag maar heeft iemand een voorbeeld?

[whoami]

Pak er even een boek/tutorial bij over Vectors.

Zoek ook eens naar dat Comperator/comparable gedoe en je bent al een heel eind vooruit.

[Glimi]

Hoe weet jouw applicatie hoe hij de clubs moet ordenen?
Dat weet hij niet. Er zijn namelijk heel veel opties
1) Ordenen op lexicografische namen
2) Ordenen op punten
3) Ordenen op gewonnen wedstrijden
4) Ordenen op gespeelde wedstrijden

Nu zijn sommige opties logischer dan andere, maar dat weet je applicatie toch niet

Wat moet ik dan doen
Stel we hebben het volgende:
Een competitie met 3 clubs A, B en C
Nu willen we de clubs sorteren op aantal punten

Daarvoor moeten we dus ervoor zorgen dat bekend wordt welke club 'hoger' moet staan dan de andere.
Hiervoor introduceren we de compareTo( Object vergelijkMet ) methode, waarin we het opgegeven clubje vergelijken met de club waarvan de methode wordt aangesproken.

Om dit bekend te maken aan het programma implementeren we de Comparable interface, zodat het programma weet dat we die methode implementeren.

En wat doet die methode dan?
Die methode geeft een negatief getal als A > B
een 0 als A = B
en een positief getal als A < B

een mogelijkde implementatie

Java:

public class Club implements Comperable {

   // mooie methodes
   // maar die zitten al in je class
   //

   // comperator functie
   // Compare op totaal aantal punten
   //
   public int compareTo( Object vergelijkingsObject ) {

      // Nu trekken we de punten van het object dat gegeven is van de punten van 
      // deze club af. Als deze club meer punten heeft, wordt het getal negatief e
      // zal deze club boven de gegeven club staan
      //  
      return (Club)vergelijkingsObject.geefPunten() - geefPunten(); 
   }
}

Als je op objecten met zo'n methode een Arrays.sort() loslaat, dan gaat ie hem mooi sorteren, op de manier die jij gedefinieerd hebt

[Verwijderd]

thnx

[Glimi]

Verwijderd schreef op 05 december 2002 @ 13:10:
thnx

Let wel op dat je hiermee een vaste sorteer mogelijkheid in je object legt. Als jij het object op een andere manier wilt sorteren, dan gaat dat niet.

Als je daar wel behoefte aan hebt, moet je voor iedere sorteermogelijkheid een object maken die de class Comperator implementeert. Deze classes werkt hetzelfde als het implementeren van de Comparable interface op je object, alleen je legt het dan vast _buiten_ je object, zodat het een pluggable iets wordt

Echter daar zou ik me pas mee bezig gaan houden als je Comparable snapt

[whoami]

Kun je ad sort functie niet meegeven welke Comparer er moet gebruikt worden?

[Glimi]

whoami schreef op 05 December 2002 @ 13:17:
Kun je ad sort functie niet meegeven welke Comparer er moet gebruikt worden?

Ja dat kan. Maar dat kan dus alleen als je een Comperator object meegeeft. Echter als jij de vergelijkingsfunctie dmv Comparable inbakt in je object, dan is dat vaststaand en is dat niet te veranderen @ runtime

(behalve als je behalve je object Comparable maakt ook nog een aantal Comperators bakt en hem dan aanspreekt met Arrays.sort( Object[], Comperator), waardoor je Comparable interface genegeerd wordt en het nu ervan me niet duidelijk is )

[Soultaker]

Sterker nog, ik kan me goed voorstellen dat je verschillende Comparator's bouwt en in je compareTo() simpelweg één specifieke zinnige Comparator gebruikt om de vergelijking naar te forwarden. Op deze manier heb je het beste van de twee werelden, zonder echt meer code te produceren.

Als je een niet-standaard methode voor vergelijking wilt, zul je inderdaad alsnog een Comparator kunnen gebruiken. Dat lijkt me zeker wel zinnig.

Dit is natuurlijk alleen zinnig als er meerdere valide manieren zijn om objecten te vergelijken. Objecten als SOFI-nummers of namen zal je in de regel gewoon op de triviale manier willen vergelijken.

[ Voor 14% gewijzigd door Soultaker op 05-12-2002 16:16 ]