Das bezweifle ich sehr. Alleine schon das hintereinander ausprobieren - du hast dich auch schon erste Hilfsstrukturen mit der hashmap und so ,.. dann geh den Weg doch ordentlich weiter ...
Also nur mal so runter geschrieben ein Ansatz - garantiert noch nicht das Ende der Fahnenstange was das Refactoring angeht, aber nur als Skizzierung:
[CODE=java] private enum Types {
BYTE(Byte.class, 0, s->Byte.parseByte(s));
// ...
public final Class<?> storedClass;
public final int sortValue;
public final Function<String, Object> converter;
public int getSortValue() { return sortValue; }
Types(final Class<?> storedClass, final int sortValue, final Function<String, Object> converter) {
this.storedClass = storedClass;
this.sortValue = sortValue;
this.converter = converter;
}
public Object tryConvert(final String value) {
try {
return converter.apply(value);
} catch (Exception ex) {
return null;
}
}
public static Object convert(final String value) {
Types[] sortedTypes = values();
Arrays.sort(sortedTypes, Comparator.comparingInt(Types::getSortValue));
for (Types type : sortedTypes) {
Object result = type.tryConvert(value);
if (result != null) return result;
}
return null;
}
}
[/CODE]
Da hat man dann keine als goto missbrauchte for Schleife und man hat auch nicht mehrfach wiederholenden Code (für unterschiedliche Typen der Parse Aufruf) und auch der Statische Block zum Initialisieren entfällt ...
Aber da kannst Du alle typen mit einer Gewichtung und der hinterlegten Parse Methode hinterlegen (Parse statt convert - das wäre ein erstes Refactoring, das mit direkt ins Auge fällt beim Schreiben ...)
So viel einfach als Bewertung von meiner Seite mit Aufzeigen einer Möglichkeit ...
