Hallo Leute,

ich habe erst vor kurzem mit Java Programmierung begonnen. Wäre sehr nett von Euch,
wenn ihr mir helfen könnt. Gibt es javaDoc in Deutsch?? / mein Englisch ist verbesserungwürdig,
bin am Lernen, aber bis dahin.....)
Ich habe mehrer Objecte gleicher Struktur, die in einem Array, empl [0], empl [1], ....aufgefangen sind. Die Objecte beinhalten zB. Namen, Tel. Nr. usw. Ich würde gerne diese Instanzvariablen sortieren, Und anschließend z.B nach den sortierten Namen die einzelnen Objekt wieder im Array platzieren.
welche Klassen kann ich dazu benutzen? kann ich die Objekte gleich sortieren, oder muß ich zuerst
die Instanzvariablen aus den Objekten herauskristallisieren, extra sortieren und dann??

public class Employee{
          private String name;
          private  String telnr;
          private String straße;

          public employee ({String name, String telnr,String straße){
               this.name = name;
               this.tel.nr = telnr;
               this.straße = straße;
          }
// Neue Datei:
public class Employeemain{ 
      public static void main (String [ ] args) {
           Employee  [] empl= new Employee [3];
            empl [0] =  (" jasmin", "089/34890"," Hagebuttenstr");
            empl [1]=  ( " bernd", 089/34555", "Blumenstraße");
            empl[2] = (" Ulirike", "089/4890", "Teufelchenstr":(

// nun würde ich gerne die Objekte nach namen sortieren und als Ergebnis wäre dann
           emplname[0] // würde eine Referenz auf das Objekt mit bernd,........ beinhalten;
           emplname[1] // würde eine Referenz sein auf das Objekt mit jasmin.......
            emplname[2] // würde.....  Ullrike.....beinhalten

wie mache ich das????

Ich danke Euch, Dir, ganz herzlich,
einen ganz lieben Gruß)
Jasmin

[Sym]

Hi,

Die API gibt es noch nicht in Deutsch. So weit ich weiß, wollte das hier mal jemand umsetzen, aber wenn Du wirklich programmieren willst, kommst Du um ein wenig Englisch nicht herum.

Zu Deiner Sortierung: Meist implementiert man sowas kurz selbst. Oder Du schaust Dir Collections an. Da gibt es meines Wissens nach sowas.

Hi,
danke für den Tipp, vieleicht finde ich ja etwas bei den Collections.
Gibt es noch einen Tip? z.B: einen Sortiermechanismus den ich bei Objekten anwenden kann?
Würde mich freuen, wenn ich eine noch etwas ausführlichere Antwort kriegen könnte.
Einen ganz lieben Gruß
Jasmin

[ehli75]

Also das Sortieren von einem Array kann man schön mit der Klasse Arrays erledigen. Dazu muss deine Klasse (die du in dem Array speicherst) das Interface Comparator implementieren ... d.h. du musst die zwei Methoden

int compare(Object o1, Object o2);
boolean equals(Object obj);

die das Interface vorschreibt implementieren. Mit der Methode compare werden zwei Objekte der klasse verglichen ... ist o1 größer als o2 gibst du 1, ist o1=o2 gibst du 0 und wenn o1 kleiner o2 gibst du -1 zurück.
(Vergleiche mit API Link !!!)
Und die Methode equals gibt true zurück wenn die Objekte gleich sind.
DAs wichtigste daran ist, dass DU festlegst, ob ein Objekt größer ist als ein anderes oder nicht ... bzw. welche Variablen herangezogen werden.
Nicht vegessen, dass die Methoden wirklich Objects haben wollen ... d.h. du musst vor dem Vergleichen casten (zumindest wars bei mir so).
Und dann kannst du ein Array ganz einfach mit der Methode

Arrays.sort( Object[], Comparator );

sortieren lassen, Der erste Parameter ist dein zu sortierendes Array und der zweite Parameter ein Objekt der Klasse im Array (ist ja ein Comparator, da du die Klasse ja das Interface implementiert!).

Ich hoffe du konntest mir folgen ... ?!? ... wenn nicht: nochmal posten.

Michael

[Ben]

Hallo

Hallo .. willkommen im Forum

Wäre sehr nett von Euch, wenn ihr mir helfen könnt.

Wir geben unser Bestes

Gibt es javaDoc in Deutsch?

Nein, SUN verbietet derzeit leider noch die Übersetzung ins Deutsch. Frag einfach nicht warum .. ich weiß es auch nicht.

Ich würde gerne diese Instanzvariablen sortieren. Und anschließend z.B nach den sortierten Namen die einzelnen Objekt wieder im Array platzieren.

Also mit einem normalen Array wird das nicht gehen. Etwas auf Deutsch (ohne Garantie auf Richtigkeit )
http://www.torsten-horn.de/techdocs/...htm#Sortierung

Würde also heißen, dass die Klasse das Interface "Comparable" implementieren muss, so dass man dann die Methode sort() aufrufen kann. Da wird dann nach natürlicher Ordnung sortiert, wenn ich das richtig verstanden habe. Das hier könnte auch interessant sein:

TreeSet und TreeMap sind immer sortiert, entweder nach "natürlicher" Ordnung oder an Hand eines dem Konstruktor übergebenen Comparator-Objekts.

oder muß ich zuerst die Instanzvariablen aus den Objekten herauskristallisieren, extra sortieren und dann?

Wenn ich aber so darüber nachdenke ... wird das wohl die Lösung sein oder wie schon erwähnt eine eigene Implementierung.

So ein "Comaparable"-Objekt würde mich aber auch mal interessieren.

Hm. Interessantes Problem ... *merk*

Grüße Ben.

edit:
zu langsam ... :

[Ben]

in Java kann man leicht mit Arrays sortieren

Tipp mal in Google folgende Stichwörter ein:

BubbleSort InsertionSort SelectionSort MergeSort ... hm gibt noch n bekanntes will mir nur gerade net einfallen ... jenachdem wieviel Objekte du sortieren willst haben die alle ihre vor und nachteile ... musst du für dich entscheiden welches du nimmst. Ich bau in der regel alle 5 ein und lass den user über config´s selbst wählen.

Hallo,

zuersteinmal danke für eure Antworten.

Michael, bitte verbessere mich, wenn ich falsch liege.
Ist es nicht so, dass wenn ich ein Interface implementiere, ich doch auch die dazugehörigen Methoden, wie hier compare und equals schreiben muß? Oder sind diese schon geschrieben?
Diese Methoden würden Objekte vergleichen, ? doch ich würde gerne die Instanzvariablen (z.B. nach Namen) der einzelnen Objekte vergleichen und dann die gesamten Objekte im Array sortieren in der Ordnung der sortieren Namen.
Gibt es da eine Lösung?

Einen ganz lieben Gruß
Jasmin

[ehli75]

Also die Methoden musst du auf jeden Fall selber implementieren ... das ist ja Sinn und Zweck des Ganzen. Die Klasse Arrays kann Arrays sortieren. Um sie sortieren zu können (das macht die glaube mit dem Quicksort-Algorithmus) muss sie zwei Einträge aus dem zu sortierenden Array miteinander vergleichen können. Nun weiss aber die Klasse Arrays nicht, wie sie Objekte deiner Klasse Employee vergleichen soll (anhand der Referenz geht das nicht). Also greift sie auf die Methoden compare und equals zurück (die DU ja implementiert hast).
Nun hast du das Problem (wenn ich das richtig verstehe), dass du je nach benutzeraktion mal nach dem Namen, mal nach der Telefonnummer ... usw. sortieren willst !?!?
Ich würde das folgender Maßen machen:
In der Klasse Employee eine statische Variable einfügen (z.B. int sort). Diese setzt du BEVOR du sortierst auf einen bestimmten Wert (da würde ich mit Konstanten arbeiten ... z.B. NAME, TELEFONNUMMER ... ). Und dann in deiner compare-Methode je nach Inhalt der Variable sort den Vergleich durchführen.
Ich versuch das mal ein wenig in Code zu fassen ...

public class Employee implements Comparator{
   ...
   private int sortConfig = 0;
   public final int NAME = 0;
   public final int TELEFONNUMMER = 1;
   public final int STRASSE = 2;
   ...

   public static void setSortConfig( int sortConfig ){
      this.sortConfig=sortConfig;
   }

   public int compare( Object o1, Object o2 ){
      Employee e1 = (Employee)o1;
      Employee e2 = (Employee)o2;
      if( sortConfig == NAME ){
         // die Namen mit einander vergleichen
      }// if NAME
      if( sortConfig == TELEFONNUMMER ){
        // die Telefonnummern miteinander vergleichen
      }// if TELEFONNUMMER
      if( sortConfig == STRASSE ){
         // die Straßennamen miteinander vergleichen
      }// if STRASSE
   }

   ...
}// class Employee

und dann machst du das in deinem Programm später so:

...
// du hast irgendwo ein Array mit Employee-Objekten ... sagen wir mal das heisst
// myEmployees ... und das soll nach dem Namen sortiert werden
Employee.setSortConfig( Employee.NAME );
Arrays.sort( myEmployees, new Employee() );
// und nun ist dein Array myEmployees nach namen sortiert.
// und wenn es nach der Telefonnummer sortiert werden soll:
Employee.setSortConfig( Employee.TELEFONNUMMER );
Arrays.sort( myEmployees, new Employee() );
// und nun ist dein Array myEmployees nach der Telefonnummer sortiert
...

ist es das was du machen willst ??

Michael

PS: sorry wegen der komischen Formatierung ... aber den Text hatte ich schön mit Leerzeichen zur Einrückung eingebeben, damit besser durchkommt ... aber in der Vorschau habe ich nun gesehen, dass das Forum die Leerzeichen alle weggenommen hat ...

Hallo Michael,

genau das ist es, was ich wollte. Danke dir!

Ich werde deinen Vorschlag gleich in die Tat umsetzen.

Einen ganz lieben Gruß
Jasmin

Hallo Michael,

würdest du so lieb sein und mir erklären warum du nach

Employee.setSortConfig(Employee.NAME);
Arrays.sort (myEmployees, ?????? new Employee() ????? );
machst??
in der javaDoc heißt es
Arrays.sort (Object [ ] a, Comperator c );

Danke dir!!!

Einen ganz lieben Gruß
Jasmin

Du hast dir die Antwort eigentlich selber schon gegeben. Dadurch teilst du ihm mit das du die compare Methode von Employee verwenden willst.

sort(T[] a, Comparator<? super T> c)
Sorts the specified array of objects according to the order induced by the specified comparator.

Danke, so macht Programmieren wieder Spaß!

Hallo,

ich muß - glaub ich - nochmal was zu dem Thema anmerken: Es gibt in Java zwei Interfaces zum Vergleichen "Comparable" und "Comparator". Beide Interfaces haben unterschiedliche Aufgaben:

Comparable dient dazu, ein Objekt selbst zu vergleichen, also Employee z.B. mit einem anderen Employee. Das Interface muß bei dem Objekt selbst implementiert werden.

Comparator hat einen ganz anderen Zweck: Es dient dazu, ANDERE Objekte miteinander zu vergleichen. Wenn z.B. Employee nicht geändert werden darf oder mehrere Vergleichmethoden eingesetzt werden sollen, is Comparator das Mittel der Wahl. Dann kann man pro zusätzlich gewünschten Vergleich ein neues Objekt konstruieren und verwenden. Ich habe das mal als Beispielprogramm unten abgebildet.

In Employee das Interface "Comparator" zu implementieren, ist zwar technisch möglich aber widerspricht dem Konzept der Interfaces völlig.

Wenn man das Programm wie unten implementiert kann man auch auf die unkonventionelle Art verzichten, mit Hilfe eines Switches die Sortierung auszutauschen.

import java.util.Arrays;
import java.util.Comparator;

class Employee implements Comparable {
  private String name;
  private String telnr;
  private String straße;

  public Employee (String name, String telnr, String straße) {
       this.name = name;
       this.telnr = telnr;
       this.straße = straße;
  }
  public String getName() { return this.name; }
  public String getStraße() { return this.straße; }
  public String getTelnr() { return this.telnr; }

  public int compareTo(Object o) {
    Employee other = (Employee)o;
    int nameResult = this.name.compareTo(other.name);
    if (nameResult != 0) return nameResult;
    int straßeResult = this.straße.compareTo(other.straße);
    if (straßeResult != 0) return straßeResult;
    return this.telnr.compareTo(other.telnr);
  }
}

class EmployeeStraßeComparator implements Comparator {
  public static EmployeeStraßeComparator SINGLETON = new EmployeeStraßeComparator();
  public int compare(Object o1, Object o2) {
    Employee e1 = (Employee)o1;
    Employee e2 = (Employee)o2;
    int straßeResult = e1.getStraße().compareTo(e2.getStraße());
    if (straßeResult != 0) return straßeResult;
    return e1.compareTo(e2);
  }
}

class EmployeeTelNrComparator implements Comparator {
  public static EmployeeTelNrComparator SINGLETON = new EmployeeTelNrComparator();
  public int compare(Object o1, Object o2) {
    Employee e1 = (Employee)o1;
    Employee e2 = (Employee)o2;
    int telnrResult = e1.getTelnr().compareTo(e2.getTelnr());
    if (telnrResult != 0) return telnrResult;
    return e1.compareTo(e2);
  }
}

class EmployeeMain {
 public static void main (String [] args) {
    Employee[] empl= new Employee [3];
    empl[0] = new Employee("jasmin", "089/34890", "Hagebuttenstr");
    empl[1] = new Employee("bernd",  "089/34555",  "Blumenstraße");
    empl[2] = new Employee("Ulirike", "089/4890", "Teufelchenstr");
    
    // sortiert nach der Straße 
    Arrays.sort(empl, EmployeeStraßeComparator.SINGLETON);
    
    // sortiert nach der Telefonnummer 
    Arrays.sort(empl, EmployeeTelNrComparator.SINGLETON);
    
    // sortiert nach dem Standardvergleicher 
    Arrays.sort(empl);
 }
}