Java Generics und numerischen Typen

Question

Ich möchte eine generische Methode schaffen, das tut effektiv diese:

class MyClass { 

    static <T extends Number> T sloppyParseNumber(String str) { 
     try { 
      return T.valueOf(str); 
     } catch (Exception e) { 
      return (T)0; 
     } 
    } 
} 

Jetzt oben nicht aus zwei Gründen nicht kompiliert: Es gibt keine Number.valueOf() Methode und 0 nicht gegossen werden T.

Beispiel Nutzung:

String value = "0.00000001"; 

System.out.println("Double: " + MyClass.<Double>sloppyParseNumber(value)); 
System.out.println("Float: " + MyClass.<Float>sloppyParseNumber(value)); 

double d = MyClass.sloppyParseNumber(value); 
float f = MyClass.sloppyParseNumber(value); 

ist über generische Methode möglich mit Java implementieren? Wenn ja, wie? Wenn nein, was ist ein guter alternativer Ansatz?

---

Edit: Es scheint einige mögliche Duplikate zu sein, aber ich habe ein nicht gefunden, was genau diese abdeckt. Ich hoffe, es gibt einen Trick zu ziehen, der diese beiden Operationen ermöglichen würde: Zeichenfolge an eine Number-Unterklasse analysieren und 0-Wert für eine Number-Unterklasse zurückgeben.

Answer 1

Ich stimme zu 100% mit TofuBeer überein. Aber falls Sie es wünschen willen zu vermeiden Ausführlichkeit für die Zeit, sollte dies auch tun:

static <T extends Number> T sloppyParseNumber(String str,Class<T> clas) { 

    if (clas == null) throw new NullPointerException("clas is null"); 

    try { 

     if(clas.equals(Integer.class)) { 
      return (T) Integer.valueOf(str); 
     } 
     else if(clas.equals(Double.class)) { 
      return (T) Double.valueOf(str); 
     } 
     //so on 

    catch(NumberFormatException|NullPointerException ex) { 
     // force call with valid arguments 
     return sloppyParseNumber("0", clas); 
    } 

    throw new IllegalArgumentException("Invalid clas " + clas); 

} 

Aber rein von T, können Sie nicht den Typ zur Laufzeit bekommen.

Answer 2

Java-Generics bieten nur Compile-Time-Prüfungen und die Typinformationen werden nach der Kompilierung praktisch weggeworfen. Daher ist die Anweisung T.valueOf in Java nicht möglich. Die Lösung ist, den ausführlichen Weg zu gehen, wie bereits in den Kommentaren erwähnt. Gibt es auch einen Grund, warum Sie MyClass.<Double>sloppyParseNumber(value), aber nicht MyClass.sloppyParseDouble(value) tun möchten, da Sie den Typ zur Kompilierungszeit angeben?

Answer 3

Statische Methoden sind durch den Typ gebunden, da der Typ bestenfalls Number und Number keine valueOf Methode hat, nach der Sie nicht arbeiten werden.

Der einfachste Weg ist, einfach eine Reihe von statischen Methoden wie sloppyParseInt zu machen, sloppyParseFloat, etc ...

Sie könnten etwas tun, nicht sicher, ob ich es mag, und kann vermutlich auf verbessert werden:

public class Main 
{ 
    private static final Map<Class<? extends Number>, NumberConverter> CONVERTERS; 

    static 
    { 
     CONVERTERS = new HashMap<>(); 
     CONVERTERS.put(Integer.class, new IntegerConverter()); 
    } 

    public static void main(String[] args) 
    { 
     Number valueA; 
     Number valueB; 

     valueA = CONVERTERS.get(Integer.class).convert("42"); 
     valueB = CONVERTERS.get(Integer.class).convert("Hello, World!"); 

     System.out.println(valueA); 
     System.out.println(valueB); 
    } 
} 

interface NumberConverter<T extends Number> 
{ 
    T convert(String str); 
} 

class IntegerConverter 
    implements NumberConverter<Integer> 
{ 
    @Override 
    public Integer convert(String str) 
    { 
     try 
     { 
      return Integer.valueOf(str); 
     } 
     catch (NumberFormatException ex) 
     { 
      return 0; 
     }  
    } 
} 

Answer 4

Also, ich nach einem alternativen Ansatz entschieden:

static String trimTo0(String str) { 
    if (str == null) return "0"; 
    str = str.trim(); 
    if (str.isEmpty()) return "0"; 
    return str; 
} 

Verbrauch:

String value = null; 
System.out println("Double value: " + Double.parseDouble(trimTo0(value))); 

Beachten Sie, dass diese geringer als das Verfahren in der Frage ist, bedeutet dies nicht ungültig konvertieren, nicht numerische Zeichenfolgen zu "0". Um dies vollständig zu tun, würden zwei getrennte Methoden benötigt, ein unterstützender Dezimalpunkt und ein anderer, der nur Ganzzahlen unterstützt.

Answer 5

Sie können dies versuchen:

private <T> T convertToType(Class<T> clazz,String str) throws Exception { 
    return clazz.getConstructor(String.class).newInstance(str); 
} 

Hier müssen Sie beachten, dass der Typ einen Konstruktor mit einem String-Parameter haben.