Trouver dynamiquement la classe qui représente une primitive de type Java

Le framework Spring contient une classe utilitaire ClassUtils qui contient la méthode statique forName. Cette méthode peut être utilisée pour la fonction exacte que vous avez décrit.

Dans le cas où vous ne voulez pas avoir une dépendance de Printemps: le le code source de la méthode peut être trouvé e. g. ici sur leur dépôt public. Le code source de la classe est sous licence Apache 2.0 modèle.

Toutefois, de noter que l'algorithme utilise une codé en dur carte des types primitifs.

Edit: Grâce à des intervenants Dávid Horváth et Patrick pour souligner le lien brisé.

Probablement vous avez juste besoin de la carte les primitives et pour le reste de la classe effectuer le "forName" méthode:

Je ferais quelque chose comme:

void someWhere(){
     String methodDescription = "doSomething int double java.lang.Integer java.lang.String"
     String [] parts = methodDescription.split();
     String methodName= parts[0]
     Class [] paramsTypes = getParamTypes( parts ); //Well, not all the array, but a, sub array from 1 to arr.length..  

    Method m = someObject.class.getMethod( methodName, paramTypes );
    etc. etc etc.
}

public Class[] paramTypes( String [] array ){
     List<Class> list = new ArrayList<Class>();
     for( String type : array ) {
         if( builtInMap.contains( type )) {
             list.add( builtInMap.get( type ) );
          }else{
             list.add( Class.forName( type ) );
          }
     }
     return list.toArray();
}  

    //That's right.
Map<String,Class> builtInMap = new HashMap<String,Class>();{
       builtInMap.put("int", Integer.TYPE );
       builtInMap.put("long", Long.TYPE );
       builtInMap.put("double", Double.TYPE );
       builtInMap.put("float", Float.TYPE );
       builtInMap.put("bool", Boolean.TYPE );
       builtInMap.put("char", Character.TYPE );
       builtInMap.put("byte", Byte.TYPE );
       builtInMap.put("void", Void.TYPE );
       builtInMap.put("short", Short.TYPE );
}

Qui est, de créer une carte où les primitives types sont stockées et si la description appartenir à une primitive puis utilisez le mappé classe. Cette carte peut également être chargé à partir d'un fichier de configuration externe, pour ajouter de la flexibilité de sorte que vous ajouter une Chaîne comme un construit, au lieu de java.lang.Chaîne ou potentiellement méthode comme ceci.

"doSomething chaîne oui|non"

Il ya beaucoup de ce genre de code dans les OS des projets comme Struts, Hibernate, Spring et Apache libs ( pour n'en citer que quelques-uns ) , de sorte que vous n'avez pas besoin de démarrer à partir de zéro.

BTW. Je n'ai pas compiler le code ci-dessus, mais je suis assez sûr qu'elle fonctionne avec peu de modifications de ne pas voter de moi pour cela.

Un certain nombre de méthodes de la Classe ne gère pas les primitives de façon cohérente malheureusement. Une façon courante autour de cette forName est d'avoir un tableau comme;

private static final Map<String, Class> BUILT_IN_MAP = 
    new ConcurrentHashMap<String, Class>();

static {
    for (Class c : new Class[]{void.class, boolean.class, byte.class, char.class,  
            short.class, int.class, float.class, double.class, long.class})
        BUILT_IN_MAP.put(c.getName(), c);
}

public static Class forName(String name) throws ClassNotFoundException {
    Class c = BUILT_IN_MAP.get(name);
    if (c == null)
        //assumes you have only one class loader!
        BUILT_IN_MAP.put(name, c = Class.forName(name));
    return c;
}

Google Guava propose com.google.common.primitives.Primitives pour ce genre de choses.