Obtention de la valeur par défaut pour les types primitifs

Question

J'ai un type primitif Java sous la main :

Class<?> c = int.class; // or long.class, or boolean.class

J'aimerais avoir un valeur par défaut pour cette classe -- plus précisément, la valeur est attribuée aux champs de ce type s'ils ne sont pas initialisés. Par exemple, 0 pour un numéro, false pour un booléen.

Existe-t-il un moyen générique de le faire ? J'ai essayé ceci :

c.newInstance()

Mais je reçois un InstantiationException et non une instance par défaut.

Answer 1

Les bibliothèques de Guava contiennent déjà cela :
http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/base/Defaults.html

Appel à defaultValue retournera la valeur par défaut pour tout type primitif (tel que spécifié par le JLS), et null pour tout autre type.

Utilisez-le comme ça :

import com.google.common.base.Defaults;
Defaults.defaultValue(Integer.TYPE); //will return 0

Answer 2

C'est ce à quoi je pense (mais qui ne passe pas le test de l'élégance) :

public class PrimitiveDefaults {
    // These gets initialized to their default values
    private static boolean DEFAULT_BOOLEAN;
    private static byte DEFAULT_BYTE;
    private static short DEFAULT_SHORT;
    private static int DEFAULT_INT;
    private static long DEFAULT_LONG;
    private static float DEFAULT_FLOAT;
    private static double DEFAULT_DOUBLE;

    public static Object getDefaultValue(Class clazz) {
        if (clazz.equals(boolean.class)) {
            return DEFAULT_BOOLEAN;
        } else if (clazz.equals(byte.class)) {
            return DEFAULT_BYTE;
        } else if (clazz.equals(short.class)) {
            return DEFAULT_SHORT;
        } else if (clazz.equals(int.class)) {
            return DEFAULT_INT;
        } else if (clazz.equals(long.class)) {
            return DEFAULT_LONG;
        } else if (clazz.equals(float.class)) {
            return DEFAULT_FLOAT;
        } else if (clazz.equals(double.class)) {
            return DEFAULT_DOUBLE;
        } else {
            throw new IllegalArgumentException(
                "Class type " + clazz + " not supported");
        }
    }
}

Answer 3

Une alternative aux goyaves Defaults.java ce qui permet à l'implémentation de déterminer les valeurs par défaut (amélioré par l'utilisation de La réponse de Antag99 ) :

import static java.util.stream.Collectors.toMap;

import java.lang.reflect.Array;
import java.util.Map;
import java.util.stream.Stream;

public class DefaultValue {
    /**
     * @param clazz
     *            the class for which a default value is needed
     * @return A reasonable default value for the given class (the boxed default
     *         value for primitives, <code>null</code> otherwise).
     */
    @SuppressWarnings("unchecked")
    public static <T> T forClass(Class<T> clazz) {
        return (T) DEFAULT_VALUES.get(clazz);
    }

    private static final Map<Class<?>, Object> DEFAULT_VALUES = Stream
            .of(boolean.class, byte.class, char.class, double.class, float.class, int.class, long.class, short.class)
            .collect(toMap(clazz -> (Class<?>) clazz, clazz -> Array.get(Array.newInstance(clazz, 1), 0)));

    public static void main(String... args) {
        System.out.println(DefaultValue.forClass(int.class)); // 0
        System.out.println(DefaultValue.forClass(Integer.class)); // null
    }
}

Answer 4

Vous pouvez le faire en réfléchissant, mais il est plus facile et plus clair de l'écrire, par ex.

Object defaultValue(Class cls)
{
  Map defaults = new HashMap();
  defaults.put(Integer.TYPE, Integer.valueOf(0));  
  defaults.put(Double.TYPE, Double.valueOf(0));  
  defaults.put(Boolean.TYPE, Boolean.FALSE);  
  //... etc
  return defaults.get(cls);
}

Bien sûr, vous voudrez probablement déplacer l'initialisation de la carte vers un constructeur ou un élément similaire pour une initialisation unique.

Raisonnablement concis - c'est élégant ?

Answer 5

Il n'y a pas de moyen élégant de le faire. En fait, il n'est même pas possible de déclarer la signature d'une méthode qui renverra les valeurs primitives en tant que telles.

Le plus proche que vous puissiez trouver est quelque chose comme ça :

public Object defaultValue(Class cls) {
    if (class == Boolean.TYPE) {
        return Boolean.FALSE;
    } else if (class == Byte.TYPE) {
        return Byte.valueOf(0);
    } else if (class == Short.TYPE) {
        ...
    } else {
        return null;
    }
}