Objekte automatisch casten

[Guest]

Hey,

ich bin gerade dabei einen generischen Comparator zu basteln, den ich in meiner gesamten Anwendung verwenden möchte. Nun stellt sich das Problem, dass natürlich je nach Ergebnisliste unterschiedliche Objekttypen zum Vergleich vorliegen. Hier mal ein kurzer Auszug:

        Comparator comparator = new Comparator() 
        {
            public int compare(Object o1, Object o2) {
            	Testobjekt c1 = (Testobjekt) o1;
            	Testobjekt c2 = (Testobjekt) o2;
                if (sortColumnName == null) {
                    return 0;
                }
                if (sortColumnName.equals("acb")) {
                    return ascending ?
                            Integer.valueOf(c1.getModuleNumber()).compareTo(Integer.valueOf(c2.getModuleNumber())) :
                            Integer.valueOf(c2.getModuleNumber()).compareTo(Integer.valueOf(c1.getModuleNumber()));
                } else return 0;
            }
        };

Derzeit wird ein Obekt der Klasse Testobjekt übergeben und je nach "sortColumnName" wird entsprechend sortiert. Nach dem "Umbau" soll jedes beliebige Objekt abgehandelt werden können. Die Variable "sortColumnName" soll dann per Reflection die getter-Methode (in diesem Fall getModuleNumber()) ersetzen. Leider weiß ich nicht so recht wie ich das automatische Casten direkt zu Beginn umsetzen soll.

 

[Der Müde Joe]

meinst du sowas:

Comparator<String> com = new Comparator<String>() {
	public int compare(String s, String t){
		return 0;
	}
};

 

[Guest]

Ne, nicht wirklich. Der Comparator bekommt ja nicht Objekte der Standard-Datentypen übergeben sondern Objekte selbst erstellter Klassen mit gettern und settern.

 

[Wildcard]

Objekt ist Objekt. Macht keinen Unterschied.

 

[Guest]

Dann verstehe ich eure Antworten irgendwie nicht bzw. falsch.

 

[manuche]

Ein String wird in Java nicht als primitiver Datentyp gehandhabt, sondern als ein Objekt der Klasse String...

 

[Marco13]

Dann verstehe ich eure Antworten irgendwie nicht bzw. falsch.

So ein Zufall. Genauso geht's uns mit deiner Frage :lol:

Vielleicht meinst du das ja so: Du willst einen Comparator, der zwei Objekte beliebigen Typs bekommt. Auf Basis einer von außen festgelegten Regel sollen diese Objekte verglichen werden. Unklar ist, wie "flexibel" das ganze sein soll, und auf was das ganze angewendet werden soll. Ein Beispiel:

class SomeType
{
    public int getSomeValue() { .... }
}

// Ein Comparator, der zwei beliebige Objekte vergleicht, indem
// er sich den Wert holt, der von der Methode "getSomeValue"
// zurückgeliefert wird
Comparator comparator = new GeneralComparator("getSomeValue");

Mit diesem Comparator könnte man dann zwei "SomeType"-Objekte vergleichen - abhängig davon, was ihre "getSomeValue"-Methoden zurückliefern.

Die compare-Methode müßte da dann SINNGEMÄSS!!! so implementiert sein:

class GeneralComparator
{
    private String methodName = ...  //  in diesem Fall "getSomeValue"

    public int compare(Object o1, Object o2) 
    { 
        Method m = o1.getClass().getMethod(methodName, ...);
        Object value1 = m.invoke(o1, ...);
        Object value2 = m.invoke(o2, ...);
        // Wenn man davon ausgehen kann, dass die 
        // zurückgegebenen Werte Comparable sind
        // (d.h. z.B. Integer oder String)
        Comparable c1 = (Comparable)value1;
        Comparable c2 = (Comparable)value2;
        return c1.compareTo(c2);
    }
}

Ein paar Fragen blieben dann noch offen, aber vielleicht kannst du sie dann entweder uns oder dir selbst beantworten :wink:

 

[Campino]

Mit diesem Comparator könnte man dann zwei "SomeType"-Objekte vergleichen - abhängig davon, was ihre "getSomeValue"-Methoden zurückliefern.

Müsste es nicht sogar möglich sein, zwei Objekte beliebigen Types zu vergleichen, solange sie nur "getSomeValue" implementieren?

Alles in allem halte ich das für zu aufwändig. Mehrere eigene Comparatoren (für jeden Objekttyp einen) zu schreiben, müsste performancemäßig besser klappen als das über Reflections zu lösen.
Notfalls nimmst du halt ein Interface, dass eine Methode compareTo(Object o) oder eine Methode getCompareValue() vorraussetzt und schreibst den Comparator für das Interface.

 

[Marco13]

Mit diesem Comparator könnte man dann zwei "SomeType"-Objekte vergleichen - abhängig davon, was ihre "getSomeValue"-Methoden zurückliefern.

Müsste es nicht sogar möglich sein, zwei Objekte beliebigen Types zu vergleichen, solange sie nur "getSomeValue" implementieren?

Ja. Hätte man vielleicht nochmal hervorheben sollen.


Alles in allem halte ich das für zu aufwändig. Mehrere eigene Comparatoren (für jeden Objekttyp einen) zu schreiben, müsste performancemäßig besser klappen als das über Reflections zu lösen.

Es geht (falls ich das richtig verstanden habe) ja nicht um einen Objekttyp (sonst wäre die erste Antwort ja schon die Lösung gewesen) sondern darum, einen Comparator zu schreiben, der "dynamsich" auf Basis des Ergebnisses einer beliebigen Methode vergleicht. Bei

class SomeType
{
    public int getSomeValue() { .... }
    public int getSomeOtherValue() { .... }
}

könnte man dann zwar auch
Comparator someTypeBySomeValueComrator = ...
Comparator someTypeBySomeOtherValueComrator = ...
erstellen, aber bei vielen Methoden könnte das auch aufwändig werden - es KÖNNTE Situationen geben, wo die reflection-Lösung die elegantere ist.

EDIT: ... insbesondere (und in Anlehnung an deine oben zitierte Aussage) könnte man ja Objekte verschiedener Klassen vergleichen, wenn sie die gleiche Methode haben .... und für sowas hätte man mit dedizierten Implementierungen wie
Comparator someTypeBySomeValueComrator = ...
Comparator someTypeBySomeOtherValueComrator = ...
Comparator someTypeAndSomeOtherTypeBySomeValueComrator = ...
Comparator someTypeAndSomeOtherTypeBySomeValueOtherComrator = ...
Comparator someTypeAndYetSomeCompletelyDifferentTypeBySomeValueComrator = ...
Comparator someTypeAndYetSomeCompletelyDifferentTypeBySomeOtherValueComrator = ...
eben eine "kombinatorische Explosion" - aber ich geb zu: Das wirkt schon arg konstruiert :roll:

 

[Guest]

Ok, ich versuche mal ein wenig Licht ins Dunkel zu bringen und meine Anforderung ein wenig detaillierter zu berschreiben. Ich brauche die Methode um in einer Webanwendung Ergebnislisten zu sortieren, indem man auf die jeweilige Spaltenüberschrift klickt. Man hat also zum Beispiel eine Liste "Kunden" und kann dann nach Vorname, Name, Straße, PLZ, etc. sortieren. Da es extrem viele solcher Ergebnislisten gibt wäre es sehr aufwendig für jede Liste eine eigene Methode zu implementieren.

Folgende POJOs stehen beispielsweise zur Verfügung:

public class Kunde
{
private String name;
private String vorname;
private String strasse;
private String ort;

.......

//getter und setter für alle private Variablen
}


public class Artikel
{
private String artikelnummer;
private String beschreibung;
private String preis;

.......

//getter und setter für alle private Variablen
}

Klickt der Anwender nun in einer Ergebnisliste auf eine Spaltenüberschrift erhalte ich folgendes zurück:

ArrayList<Kunde> liste; // oder ArrayList<Artikel> liste;
String spaltenname;

Und genau diese Informationen möchte ich an den Comparator übergeben. Eine Liste mit belibigem Inhalt und einen Spaltennamen. Er soll also die Liste nach dem Wert sortieren, den er über getSpaltenName aus dem Objekt bekommt.

 

[Gast]

reflection ist bei weitem nicht mehr so lahm, wie vor einigen jahren, aber ich würd meinen zeilenobjekten wahrscheinlich trotzdem einfach paar methoden spendieren, um metainformationen zu erhalten. z.b. mit einem interface dieser art:

interface TableRow
{
   int numFields();
   String getField( int index );
   int findField( String name );
}