Collections{Liste aus Objekten erzeugen]

Status
Nicht offen für weitere Antworten.

mamelinchen

Bekanntes Mitglied
Es geht darum,eine abstrakte Klasse namens AbstractPerson zu schreiben
mit Vornamen,Nachnamen,usw.

Die Klassen Persdon und Comparable Person erben von dioeser Klasse und enthalten eine public boolean equals Methode, die überprüft, ob das Objekt null ist, und ob die Instanzvariablen gleichwertig sind.

Ich habe alle Instanzvariablen als Strings deklariert, dazu die Postleitzahl, da sie ja führende Nullen haben kann und als int würden sie verschwinden.Ebenso beim Geburtsjahr, da dieses ja auch als 79 ,anstattt 1979 angegeben werden kann.

ComparablePerson implementiert ebenso java.lang.Comparable<ComparablePerson>
Dies soll die CP-Objekte anhand des Nachnamens, Vornamens,usw. vergleichen.

Die mach ich durch die String.compareTo-Methode ,die von equals aufgerufen wird.

Mein Problem besteht in der Aufgabe:
Textdatei ,in der die Vornamen,nachnamen ....stehen,ungeordnet.10 Zeilen.
In der Klasse Names sollen die Methoden public static List getTestNames() und public static List getTestNamesComparable(), die jeweils die txt einlesen ,für jede Zeile
ein Objekt erzeugen und alle Objekte in einer Liste zurückgeben.

Meine Frage:
Umwandlung in ein String-Objekt oder Person oder ComparablePerson.Objekt?
Ich lese ja die Strings mit ner while-Schleife ein mit readLine().
Logischer ist ja das jeweils eine Zeile eine Person ergibt.
Soll ich die 4 "Wörter" einlesen und dann in ein Person-Objekt umwandeln und dieses dann der Liste hinzufügen?

Ich verstehe den Unterschied der beiden Methoden (wenn als String eingelesen wird)
nicht🙁


Und was ist dann der Unterschied zu der Comparable-Methode?

Ich zeig mal was ich da so fabriziert habe:

Code:
public class ComparablePerson extends AbstractPerson implements Comparable<ComparablePerson>{

    public ComparablePerson(String vorname, String nachname, String geburtsjahr,
            String postleitzahl) {
        super(vorname, nachname, geburtsjahr, postleitzahl);
    }

    public ComparablePerson(ComparablePerson person){
        this(person.vorname,person.nachname,person.geburtsjahr,person.postleitzahl);
    }
    
    public boolean equals(Object o){
        if(!(o instanceof ComparablePerson)){
            return false;
        }
        
        ComparablePerson other=(ComparablePerson)o;
            return 0!=compareTo(other);
            
    }
    
    public int compareTo(ComparablePerson person) {
        if(0!= this.nachname.compareTo(person.nachname)){
            
        if(0!= this.vorname.compareTo(person.vorname)){
            
        if(0!= this.geburtsjahr.compareTo(person.geburtsjahr)){
            
        if(0!= this.postleitzahl.compareTo(person.postleitzahl)){
        }
        }
        }
        }
            return 0;
    }
    
}
und die Names:
Code:
public class Names {
    
    
    public static void main (String arg[])throws IOException {
        Locale.setDefault(Locale.US);
        System.out.println(getTestNames());
        System.out.println(getTestNamesComparable());
        
    }
    
    public static List getTestNames() throws IOException{
        LineNumberReader read=new LineNumberReader(
                  new BufferedReader(
                      new FileReader(
                          new File( "../pr2/src/a01/testNamen.txt" )
                      )
                  )
               );
        
        String[]lines=new String[10];
        ArrayList<String> namesList = new ArrayList<String>();
        for(int i=0; i<lines.length;i++){
            lines[i]=read.readLine();
            namesList.add(lines[i]);
        }
            return namesList;
    }
    
    public static List getTestNamesComparable() throws IOException{
        LineNumberReader read=new LineNumberReader(
                  new BufferedReader(
                      new FileReader(
                          new File( "../pr2/src/a01/testNamen.txt" )
                      )
                  )
               );
        String[]lines2=new String[10];
        ArrayList<String> namesComparableList = new ArrayList<String>();
        for(int i=0; i<lines2.length;i++){
            lines2[i]=read.readLine();
            namesComparableList.add(lines2[i]);
        }
        return namesComparableList;
        
    }

}
Lese hier nur die Strings je Zeile ein und füge diese der Array-List hinzu.
Eine normale List kann man nicht erzeugen, bekomme ne Exception.
Kann mir einer sagen warum?

Is alles okay soweit????:L
 
Lese hier nur die Strings je Zeile ein und füge diese der Array-List hinzu.
Eine normale List kann man nicht erzeugen, bekomme ne Exception.
Kann mir einer sagen warum?

Hi,

was ist eine normale List? Von List selbst kannst du keine Isntanz erzeugen, weil es ein Interface ist.
Du könntest höchstens schreiben:
[highlight=Java]List<String> namesComparableList = new ArrayList<String>();[/highlight]
 
Code:
public int compareTo(ComparablePerson person) {
        if(0!= this.nachname.compareTo(person.nachname)){
            
        if(0!= this.vorname.compareTo(person.vorname)){
            
        if(0!= this.geburtsjahr.compareTo(person.geburtsjahr)){
            
        if(0!= this.postleitzahl.compareTo(person.postleitzahl)){
        }
        }
        }
        }
            return 0;
}
Hier wird IMMER 0 zurückgegeben -- sehr merkwürdige Implementation.
 
Code:
public int compareTo(ComparablePerson person) {
        int zahl=0;
        if(zahl== this.nachname.compareTo(person.nachname)){
            
        if(zahl== this.vorname.compareTo(person.vorname)){
            
        if(zahl== this.geburtsjahr.compareTo(person.geburtsjahr)){
            
        if(zahl== this.postleitzahl.compareTo(person.postleitzahl)){
            return zahl;
        }
        }    
        }
        }
        return 1;
bezza?
 
Code:
public int compareTo(ComparablePerson person) {
        int zahl=0;
        if(zahl== this.nachname.compareTo(person.nachname)){
            
        if(zahl== this.vorname.compareTo(person.vorname)){
            
        if(zahl== this.geburtsjahr.compareTo(person.geburtsjahr)){
            
        if(zahl== this.postleitzahl.compareTo(person.postleitzahl)){
            return zahl;
        }
        }    
        }
        }
        return 1;
bezza?

Bist du dir sicher, daß dieser Code irgend etwas vernünftiges zurückliefert? :shock:
 
Wo wird denn da -1 zurückgegeben? Guck dir in der Api nochmal Comparable --> compareTo(T) an.

So ist das nur sowas ähnliches wie equals.
 
Gesagt wurde, man solle sich die API angucken mit compareTo, aber boolean equals verwenden?
Ich weiss das -1 gegeben wird , wenn less, 0 wenn equal und 1 wenn higher.
Es soll ja nur bei equals zurückgegeben werden:false oder true.
Was hab ich dann von einer 1 oder -1?Ist doch dann eh false, oder nicht?


Danke!

PS:Und seid net so geschockt:shock:,
programmier erst seit 4 monaten:autsch:
 
compareTo bietet mehr Funktionen als equals. Wenn du nur equals zurückliefern sollst dann mach
Code:
public int compareTo(ComparablePerson cp){
   return equals(cp) ? 0 : 1;
}
 
Gesagt wurde, man solle sich die API angucken mit compareTo, aber boolean equals verwenden?
Ich weiss das -1 gegeben wird , wenn less, 0 wenn equal und 1 wenn higher.
Es soll ja nur bei equals zurückgegeben werden:false oder true.
Was hab ich dann von einer 1 oder -1?Ist doch dann eh false, oder nicht?

Hä?

Ich meinte, dass dein compareTo nur sowas ähnliches wie equals leistet. Aber ein compareTo soll, wie über mir gesagt, mehr können. Das scheinst du ja zu wissen, also warum implementierst du das nicht so?
 
compareTo bietet mehr Funktionen als equals. Wenn du nur equals zurückliefern sollst dann mach
Code:
public int compareTo(ComparablePerson cp){
   return equals(cp) ? 0 : 1;
}

Damit werden eine ganze Reihe von Regeln verletzt - im spziellen die, die in Comparable (Java Platform SE 6) zugesichert sind. D.h. wenn man das ganze dann in eine Set einfügt, kommt eine ungültige Set raus...
 
Ja, sicher, da fehlte ein "Tree" - aber auch in anderen Fällen kann das ... "unerklärliche" Effekte haben... die Aussage "a>b && b>a" sollte i.a. "false" sein...
 
okay!liefert genau das was halt compareTo können sollte:

Code:
    public int compareTo(ComparablePerson person) {
        int zahl=0;
        if(zahl!= this.nachname.compareTo(person.nachname)){
            return zahl=this.nachname.compareTo(person.nachname);
        }    
        else if(zahl!= this.vorname.compareTo(person.vorname)){
            return zahl= this.vorname.compareTo(person.vorname);
        }
        else if(zahl!= this.geburtsjahr.compareTo(person.geburtsjahr)){
            return zahl= this.geburtsjahr.compareTo(person.geburtsjahr);
        }    
        else if(zahl!= this.postleitzahl.compareTo(person.postleitzahl)){
            return zahl= this.postleitzahl.compareTo(person.postleitzahl);
        }
        else return zahl;
        
    }
 
Code:
public int compareTo(ComparablePerson person) 
{
        int zahl=0;
        zahl=this.nachname.compareTo(person.nachname);
        if (zahl != 0) return zahl;
        zahl = this.vorname.compareTo(person.vorname);
        if (zahl != 0) return zahl;
        zahl= this.geburtsjahr.compareTo(person.geburtsjahr);
        if (zahl != 0) return zahl;
        zahl= this.postleitzahl.compareTo(person.postleitzahl);
        return zahl;
}
 
Kann man meinen oberen Quellcode vereinfachen?
Jup... z.B. so[highlight= java]public int compareTo(ComparablePerson person) {
int zahl;
if((zahl = this.nachname.compareTo(person.nachname)) != 0) {
return zahl;
}
if((zahl = this.vorname.compareTo(person.vorname)) != 0) {
return zahl;
}
if((zahl = this.geburtsjahr.compareTo(person.geburtsjahr)) != 0) {
return zahl;
}
if((zahl = this.postleitzahl.compareTo(person.postleitzahl)) != 0) {
return zahl;
}
return 0;
}[/highlight]Der Vorteil: die einzelnen "compareTo"-Methoden werden nur einmal aufgerufen und zwar nur solange "zahl == 0" ist. Möglicherweise gehts auch noch einfacher, aber ich sicher nicht gleichzeitig übersichtlicher.
@Edit: da war jemand schneller... Was soll's das Ergebnis ist fas selbe.
 
Zuletzt bearbeitet von einem Moderator:
Damit werden eine ganze Reihe von Regeln verletzt - im spziellen die, die in Comparable (Java Platform SE 6) zugesichert sind. D.h. wenn man das ganze dann in eine Set einfügt, kommt eine ungültige Set raus...

Richtig!
Aber er hat ja gesagt dass er im Endeffekt _nur_ ein equals erreichen will.

Ich hab ja nirgends geschrieben dass die Implementierung so korrekt oder empfehlenswert ist.
Ich würde es so definitiv nicht machen 🙂
 
Status
Nicht offen für weitere Antworten.

Zurück
Oben