I need a method that returns an instance of the supplied class type. Let's assume that the supplied types are limited to such that an "empty" instance of them can be created. For instance, supplying String.class
would return an empty String, supplying an Integer.class
would return an Integer whose initial value is zero, and so on. But how do I create (boxed) primitive types on the fly? Like this?
public Object newInstance(Class<?> type) {
if (!type.isPrimitive()) {
return type.newInstance(); // plus appropriate exception handling
} else {
// Now what?
if (type.equals(Integer.class) || type.equals(int.class)) {
return new Integer(0);
}
if (type.equals(Long.class) // etc....
}
}
Is the only solution to iterate through all the possible primitive types, or is there a more straightforward solution? Note that both
int.class.newInstance()
and
Integer.class.newInstance()
throw an InstantiationException
(because they don't have nullary constructors).
Types in Java come in two flavors, primitive types (int, long, etc) and reference types (String, List, etc). Each primitive type has a corresponding reference type called a boxed primitive.
They convert primitive data types into objects. Objects are needed if we wish to modify the arguments passed into a method (because primitive types are passed by value). The classes in java. util package handles only objects and hence wrapper classes help in this case also.
Converting a primitive value (an int, for example) into an object of the corresponding wrapper class (Integer) is called autoboxing. The Java compiler applies autoboxing when a primitive value is: Passed as a parameter to a method that expects an object of the corresponding wrapper class.
I suspect the simplest way is to have a map:
private final static Map<Class<?>, Object> defaultValues =
new HashMap<Class<?>, Object>();
static
{
defaultValues.put(String.class, "");
defaultValues.put(Integer.class, 0);
defaultValues.put(int.class, 0);
defaultValues.put(Long.class, 0L);
defaultValues.put(long.class, 0L);
defaultValues.put(Character.class, '\0');
defaultValues.put(char.class, '\0');
// etc
}
Fortunately all these types are immutable, so it's okay to return a reference to the same object on each call for the same type.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With