Casting

[Carcharoth]

Guten Tag

Ich kann mir zwar denken, dass folgendes unter dem Aspekt Typensicherheit nicht gerade vorbildlich ist, aber wieso funktioniert folgendes nicht?

        Class fieldType = Integer.class;
        String text = "13";
        
        Object ganzZahl = fieldType.cast(text);

 

[Robert Zenz]

Weil ein String und ein Integer nicht das selbe sind...schlicht und ergreifend. "cast" bedeutet dass ein Objekt bereits von diesem Typ ist aber der Kompilierer/IDE es nicht wissen kann. Du weiszt es aber, deswegen gibst du es ja auch explizit an. In diesem Fall willst du wahrscheinlich Integer.parseInt(String) verwenden.

 

[Carcharoth]

OK, verstehe ich.
Mein Beispiel ist natürlich stark vereinfacht. In Wirklichkeit weiss ich bei meiner letzten Codezeile nicht welcher Klasse fieldType entspricht.
Gibt es eine Möglichkeit - ähnlich wie ich es mit cast gemacht habe - eine "allgemeine" parse-Methode zu nutzen?

Also so was wie (ich weiss, dass es so nicht geht, aber vielleicht gibt es einen anderen Weg?):

Class fieldType = Integer.class;
String text = "13";
        
Object ganzZahl = fieldType.parse(text);

 

[Robert Zenz]

Was genau hast du vor? Also was willst du machen? Ich glaube dein Beispiel ist ungeeignet um deinen eigentlichen Anwendungsfall zu repraesentieren.

Wenn du ein Objekt hast und wissen willst ob es eine bestimmte Klasse ist, gibt es da instanceof und Class.isAssignableFrom um dies zu testen bevor du dann einen Cast machst welcher moeglicherweise zur Laufzeit fehlschlaegt.

 

[Carcharoth]

Ich lese Strings aus einer Quelle (z.B. csv-Datei).
Der Array fieldTypes gibt Auskunft darüber was für Typen die Strings eigentlich beinhalten.
Ich möchte jedes String daher gleich in den richtigen Datentyp umwandeln und ihn in eine ArrayList von Objekten speichern.
Später wird eine Methode die Objekte des ArrayLists verarbeiten.

Class[] fieldTypes = new Class[] {Integer.class, String.class, String.class, String.class, String.class, Double.class, Double.class, String.class};
        
ArrayList<Object> daten = new ArrayList<>();

for (int i = 1;i<=columnCount;i++ ) {
    daten.add(fieldTypes[i-1].parse(getString(i)));   
}

 

[Carcharoth]

Ich habe es provisorisch wie folgt gelöst, aber ich dachte es ginge eleganter bzw. kompakter.

for (int i = 1;i<=columnCount;i++ ) {
    if (fieldTypes[i-1].equals(Integer.class)) {
        daten.add(Integer.valueOf(res.getString(i)));
    } else if (fieldTypes[i-1].equals(Double.class)) {
        daten.add(Double.valueOf(res.getString(i)));
    } else if (fieldTypes[i-1].equals(Boolean.class)) {
        daten.add(Boolean.valueOf(res.getString(i)));
    } else {
        daten.add(res.getString(i));
    }
}

 

[KonradN]

Ich wundere mich hier gerade, dass Du nur die Typen und ein getString hast. Hast Du keine weiteren get Methoden um z.B. ein Object zu bekommen? Dann wäre kein parsen auf Deiner Seite notwendig.

Ansonsten sehe ich mehrere Möglichkeiten:

Um diese if else if Konstruktion los zu werden, könnte man einfach eine Map nehmen. Alsp etwas wie Map<Class, Function<String, Object>>, welche einmalig mit den unterstützen Typen gefüllt wird, also etwas wie: myConverters.put(Integer.class, s -> Integer.valueOf(s) );

Dann wäre die Umsetzung nur: Aus der Map den entsprechenden Eintrag verwenden und nutzen so er nicht null ist. Ansonsten den String direkt nehmen.

Eine andere Möglichkeit könne eine Enumeration sein. Du hast eine Enumeration, wobei jeder Eintrag so wie jeder Map-Eintrag auch die class und die Function hat. Und dann hast Du eine Methode, die alle values der Enumeration durchgeht. Wenn der classValue == dem übergebenen Typ ist, dann wird das Ergebnis des Methodenaufrufs zurück gegeben. Ansonsten wird der String zurück gegeben. Mit nur einem Typ mal gezeigt, wie der Rahmen aussieht:

import java.util.function.Function;

public enum TypeConverter {
    
    INTEGER(Integer.class, s -> Integer.valueOf(s) );
    
    Class classValue;
    Function<String, Object> convertFunction;
    
    TypeConverter(Class classValue, Function<String, Object> convertFunction) {
        this.classValue = classValue;
        this.convertFunction = convertFunction;
    }
    
    public Object convert(String value) {
        return convertFunction.apply(value);
    }
    
    public static Object convert(Class classValue, String value) {
        for (TypeConverter converter : values()) {
            if (converter.classValue.equals(classValue)) {
                return converter.convert(value);
            }
        }
        return value;
    }
}

Dritte Variante:
Und da jedes Mal die valueOf Methode aufgerufen wird, ist hier natürlich auch denkbar, Reflection zu verwenden um in der Klasse nach der Methode valueOf zu schauen um diese dann aufzurufen. Diese Variante würde ich aber nicht nehmen. Selbstw enn man diesen Weg nehmen würde, würde ich einmalig eine Map aufbauen nur eben wäre die Function<String, Object> einmalig über Reflection erstellt worden. Sprich: Es wird nicht immer nach der Methode gesucht. Die Methode wird pro Typ nur einmalig gesucht und dann gespeichert.

 

[underConstruction]

Konrad hat hier mal recht. Man braucht für das was du vor hast eine Map. Du willst einfach gesagt die Typkonvertierung um eigene Casts ergänzen.

 

[KonradN]

Man braucht für das was du vor hast eine Map.

Wie ich gezeigt habe: Es gibt auch andere Lösungen. Es braucht eben keine Map. Der TE hat eine Lösung gefunden und die funktioniert. Und dann kann man es umschreiben. Ob eine Map da zielführend ist oder nicht hängt mit von den weiteren Anforderungen ab. Eine Festlegung, dass man da eine Map braucht, ist also erst einmal ganz offensichtlich nnicht ganz korrekt.

Du willst einfach gesagt die Typkonvertierung um eigene Casts ergänzen.

Es geht aber doch um keine Casts. Der TE hat in dem Code, den er geschrieben hat, ja ganz klar keine Casts enthalten. Und auch die übrigen Ideen kommen ohne ein Cast aus. Daher ist gerade unklar, wo Du hier Casts siehst.