Sortering ??

Grave grave - jo, jeg havde vist sådan én liggende:


class SorteringsDemo {

  public static class Person implements Comparable {
    public String navn;
    public int alder;

    public Person(String navn, int alder) {
      this.navn=navn;
      this.alder=alder;
    }

    public int compareTo(Object p) {
      return this.alder-((Person)p).alder;
    }

    public String toString() {
      return navn+\" \"+alder;
    }
  };

  public static void main(String[] args)     {
      Person personer[] = new Person[10];
      personer[0]=new Person(\"Hans\",3);
      personer[1]=new Person(\"Hans\",4);
      personer[2]=new Person(\"Hans\",6);
      personer[3]=new Person(\"Hans\",2);
      personer[4]=new Person(\"Hans\",11);
      personer[5]=new Person(\"Hans\",99);
      personer[6]=new Person(\"Hans\",44);
      personer[7]=new Person(\"Hans\",33);
      personer[8]=new Person(\"Hans\",32);
      personer[9]=new Person(\"Hans\",31);

      java.util.Arrays.sort(personer);

      for (int i=0;i<10;i++) {
        System.out.println(personer[i]);
      }
  }
}

et bud kunne måske være
public int compareTo(SomeObject otherObject){
if(this.intValue < otherObject.getIntValue())
  return -1;
else if(this.intValue == otherObject.getIntValue())
  return 0;
else
  return 1;
}

Det er ihvertfald en måde at løse problemstillingen på.

Dette giver bare det problem at denne metode indikerer at de objekter er ens hvis der returneres 0. Dette vil måske ikke være tilfældet hvis der er flere variable i objekterne der til sammen giver et unikt objekt.

Alternativt kunne man implementere
public boolean lessThan(SomeObject otherObject)
og
public boolean greaterThan(SomeObject otherObject)

Så vil man ikke kunne indikere at de to objekter er ens, bare fordi at den ene variabel er den samme.

Du har nu ret i én ting, lb, nemlig at min compareTo() er dum. Den bør nemlig kun
returnere 0 når er tilsvarende equals() giver true. Egentlig bør man bruge den version
af java.util.Arrays.sort(), der tager en sammenligningsfunktion med som parameter.

Mon spørgeren er interesseret i det?

Det er vel lige meget ved en sortering på et bestemt felt. Hvis flere objekter indeholder samme værdi, kan man ikke afgøre hvem der kommer først. Så må man sortere på et ekstra felt.

det ved jeg ikke om han er. Nu fik han bare lidt
ekstra info for pointene:)

Men Comparator er en dejlig inkludering i apiet.

Jo, stigc, for equals og compareTo skal jo formentlig bruges i anden sammenhæng,
hashtabeller fx. Derfor er mit arkæologiske gravearbejde i princippet spildt. Jeg må
have lavet den løsning for at afteste et eller andet ...

Der bør laves en Comparator, som lb siger - men jeg kan ikke liiige finde et eksempel.
Men vi kan jo lave det, hvis spørgeren vil ha\' det.

erik >> Der vil din metode i dit eksempel være fint at implementere i en AgeComparator. Der må
den jo godt returnere 0, da det giver mening fordi denne Comparator netop vil have til formåle at undersøge disse to felter i to objekter.

Der behøver da ikke leveres kode til alt, der skal da også være mulighed for at folk selv kan være lidt kreative:)

Nu er da i denne diskussion blevet afsløret at
der findes
java.util.Arrays, og java.util.Comparator

Den skal da bruges her

java.util.Arrays.sort(personer);

hvor JAVA bruger en quicksort.

om igen, det er en mergesort i følge java.sun.com

Lad os vise hvad vi mener, ikke?

class SorteringsDemo {

  public static class Person {
    public String navn;
    public int alder;

    public Person(String navn, int alder) {
      this.navn=navn;
      this.alder=alder;
    }

    public String toString() {
      return navn+\" \"+alder;
    }
  };

  public static class AgeComparator implements java.util.Comparator  {
    public int compare(Object p,Object q) {
      return ((Person)p).alder-((Person)q).alder;
    }
  };

  public static void main(String[] args)     {
      Person personer[] = new Person[10];
      personer[0]=new Person(\"Hans\",3);
      personer[1]=new Person(\"Hans\",4);
      personer[2]=new Person(\"Hans\",6);
      personer[3]=new Person(\"Hans\",2);
      personer[4]=new Person(\"Hans\",11);
      personer[5]=new Person(\"Hans\",99);
      personer[6]=new Person(\"Hans\",44);
      personer[7]=new Person(\"Hans\",33);
      personer[8]=new Person(\"Hans\",32);
      personer[9]=new Person(\"Hans\",31);

      java.util.Arrays.sort(personer,new AgeComparator());

      for (int i=0;i<10;i++) {
        System.out.println(personer[i]);
      }
  }
}

stigc>> Arrays sorterer små mængder (<7) med insertion sort, og større mængder (>=7) med quicksort. Store arrays (>40) deles i ni bidder, som sorteres med quicksort, og merges (fra mergesort) bagefter. Det er algoritmerne i 1.3

Collections.sort bruger samme algoritme (idet de bare kalder toArray på en collection, sorterer arrayet og propper elementerne tilbage igen)


erikjacobsen>> Til hashing har du bare brug for hashCode og equals, men de skal til gengæld også være korrekte. Problemerne opstår i SortedSet og SortedMap definitioner, fordi de har en noget tung kontrakt.

Læser man API på Comparable, siger den:
It is strongly recommended (though not required) that natural orderings be consistent with equals
Altså at (a.compareTo(b)==0) == a.equals(b) og alle Comparable klasser i java er da også ok i den sammenhæng.

Hej...

Tak for hjælpen og indputtene...

Brugte faktisk dele fra jeg begge...

/arno