Java Top

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:


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:


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:


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:


Then let's test it:


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:


Likewise, we can test it using:


However, the Primitives.isWrapperType method won't work on the primitive class, the following code will returns false:


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.

Java bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

Comments are closed on this article!