1. Overview
Sometimes we need to determine if an object is of primitive type, especially for wrapper primitive types. However, there are no built-in methods in the standard JDK to achieve this.
In this quick tutorial, we’ll see how to implement a solution using core Java. Then we’ll take a look at how we can achieve this using a couple of commonly used libraries.
2. Primitives and Wrapper Classes
There are nine predefined objects to represent eight primitives and a void type in Java. Each primitive type has a corresponding Wrapper Class.
To learn more about Primitives and Objects, please see this article.
The java.lang.Class.isPrimitive() method can determine if the specified object represents a primitive type. However, it does not work on the wrappers for primitives.
For example, the following statement returns false:
Integer.class.isPrimitive();
Now let’s take a look at different ways we can achieve this.
3. Using Core Java
First, let’s define a HashMap variable which stores the wrapper and the primitive type classes:
private static final Map<Class<?>, Class<?>> WRAPPER_TYPE_MAP;
static {
WRAPPER_TYPE_MAP = new HashMap<Class<?>, Class<?>>(16);
WRAPPER_TYPE_MAP.put(Integer.class, int.class);
WRAPPER_TYPE_MAP.put(Byte.class, byte.class);
WRAPPER_TYPE_MAP.put(Character.class, char.class);
WRAPPER_TYPE_MAP.put(Boolean.class, boolean.class);
WRAPPER_TYPE_MAP.put(Double.class, double.class);
WRAPPER_TYPE_MAP.put(Float.class, float.class);
WRAPPER_TYPE_MAP.put(Long.class, long.class);
WRAPPER_TYPE_MAP.put(Short.class, short.class);
WRAPPER_TYPE_MAP.put(Void.class, void.class);
}
If the object is a primitive wrapper class, we can look it up from the predefined HashMap variable with java.utils.Map.ContainsKey() method.
Now we can create a simple utility method to determine if the object source is of a primitive type:
public static boolean isPrimitiveType(Object source) {
return WRAPPER_TYPE_MAP.containsKey(source.getClass());
}
Let’s validate that this works as expected:
assertTrue(PrimitiveTypeUtil.isPrimitiveType(false));
assertTrue(PrimitiveTypeUtil.isPrimitiveType(1L));
assertFalse(PrimitiveTypeUtil.isPrimitiveType(StringUtils.EMPTY));
4. Using Apache Commons – *ClassUtils.*isPrimitiveOrWrapper()
Apache Commons Lang has a ClassUtils.isPrimitiveOrWrapper method that can be used to determine if a class is a primitive or a wrapper of primitive.
First, let’s add the commons-lang3 dependency from Maven Central to our pom.xml:
<dependency>
<groupId>org.apache.commons<groupId>
<artifactId>commons-lang3<artifactId>
<version>3.12.0<version>
<dependency>
Then let’s test it:
assertTrue(ClassUtils.isPrimitiveOrWrapper(Boolean.False.getClass()));
assertTrue(ClassUtils.isPrimitiveOrWrapper(boolean.class));
assertFalse(ClassUtils.isPrimitiveOrWrapper(StringUtils.EMPTY.getClass()));
5. Using Guava – *Primitives.*isWrapperType()
Guava provides a similar implementation via the Primitives.isWrapperType method.
Again, let’s add the dependency from Maven Central first:
<dependency>
<groupId>com.google.guava<groupId>
<artifactId>guava<artifactId>
<version>31.0.1-jre<version>
<dependency>
Likewise, we can test it using:
assertTrue(Primitives.isWrapperType(Boolean.FALSE.getClass()));
assertFalse(Primitives.isWrapperType(StringUtils.EMPTY.getClass()));
However, the Primitives.isWrapperType method won’t work on the primitive class, the following code will returns false:
assertFalse(Primitives.isWrapperType(boolean.class));
6. Conclusion
In this tutorial, we illustrated how to determine if an object can represent a primitive data type using our own implementation using Java. Then we took a look at a couple of popular libraries that provide utility methods for achieving this.
The complete code can be found over on Github.