Determine if an Object is of Primitive Type – 确定一个对象是否属于原始类型

最后修改: 2020年 8月 7日

中文/混合/英文(键盘快捷键：t)

1. Overview

1.概述

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.

有时我们需要确定一个对象是否属于原始类型，特别是对于包装原始类型。然而，在标准的JDK中没有内置的方法来实现这一点。

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.

在这个快速教程中，我们将看到如何使用核心Java来实现一个解决方案。然后，我们将看看如何使用几个常用的库来实现这一目标。

2. Primitives and Wrapper Classes

2.基元和封装类

There are nine predefined objects to represent eight primitives and a void type in Java. Each primitive type has a corresponding Wrapper Class.

在Java中，有九个预定义的对象来代表八个基元和一个void类型。每个基元类型都有一个相应的封装类。

To learn more about Primitives and Objects, please see this article.

要了解有关Primitives和Objects的更多信息，请参见此文章。

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.

java.lang.Class.isPrimitive()方法可以确定指定的对象是否代表一个原始类型。但是，它对基元的封装器不起作用。。

For example, the following statement returns false:

例如，以下语句返回false。

Integer.class.isPrimitive();

Now let’s take a look at different ways we can achieve this.

现在让我们来看看我们可以通过哪些不同的方式来实现这一目标。

3. Using Core Java

3.使用Core Java

First, let’s define a HashMap variable which stores the wrapper and the primitive type classes:

首先，让我们定义一个HashMap变量，它存储了包装器和原始类型类。

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.

如果对象是一个原始的封装类，我们可以用java.utils.Map.ContainsKey()方法从预定义的HashMap变量中查找它。

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()

4.使用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.

Apache Commons Lang有一个ClassUtils.isPrimitiveOrWrapper方法，可以用来确定一个类是原始类还是原始类的包装器。

First, let’s add the commons-lang3 dependency from Maven Central to our pom.xml:

首先，让我们把Maven Central的commons-lang3依赖性添加到我们的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()

5.使用Guava – Primitives.isWrapperType（）

Guava provides a similar implementation via the Primitives.isWrapperType method.

Guava通过Primitives.isWrapperType方法提供了一个类似的实现。

Again, let’s add the dependency from Maven Central first:

同样，我们先从Maven Central添加依赖。

<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:

但是，Primitives.isWrapperType方法对基元类不起作用，下面的代码将返回错误。

assertFalse(Primitives.isWrapperType(boolean.class));

6. Conclusion

6.结语

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.

在本教程中，我们说明了如何使用我们自己的Java实现来确定一个对象是否可以代表一个原始数据类型。然后我们看了几个流行的库，它们提供了实现这一目的的实用方法。

The complete code can be found over on Github.

完整的代码可以在Github上找到over。