blocks|key|4618121|text|Object[]中的类型永远不会是原始的--因为你已经有了引用！这里，i的类型是int，而o引用的对象类型是Integer+(由于自动装箱)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4618122|听起来你需要找出这个类型是否是“原语的包装器”。我不认为标准库中有任何内置的东西，但是很容易编写代码：|4618123|import+java.util.*;

public+class+Test
{
++++public+static+void+main(String[]+args)++++++++
++++{
++++++++System.out.println(isWrapperType(String.class));
++++++++System.out.println(isWrapperType(Integer.class));
++++}

++++private+static+final+Set<Class<?>>+WRAPPER_TYPES+=+getWrapperTypes();

++++public+static+boolean+isWrapperType(Class<?>+clazz)
++++{
++++++++return+WRAPPER_TYPES.contains(clazz);
++++}

++++private+static+Set<Class<?>>+getWrapperTypes()
++++{
++++++++Set<Class<?>>+ret+=+new+HashSet<Class<?>>();
++++++++ret.add(Boolean.class);
++++++++ret.add(Character.class);
++++++++ret.add(Byte.class);
++++++++ret.add(Short.class);
++++++++ret.add(Integer.class);
++++++++ret.add(Long.class);
++++++++ret.add(Float.class);
++++++++ret.add(Double.class);
++++++++ret.add(Void.class);
++++++++return+ret;
++++}
}|code-block|syntax|javascript|4618124|entityMap^0|0|8|Z|1|14|3|19|1|1I|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

The types in an <code>Object[]</code> will never really be primitive - because you've got references! Here the type of <code>i</code> is <code>int</code> whereas the type of the object referenced by <code>o</code> is <code>Integer</code> (due to auto-boxing).

It sounds like you need to find out whether the type is a "wrapper for primitive". I don't think there's anything built into the standard libraries for this, but it's easy to code up:

<pre><code>import java.util.*;

public class Test
{
 public static void main(String[] args) 
 {
 System.out.println(isWrapperType(String.class));
 System.out.println(isWrapperType(Integer.class));
 }

 private static final Set&lt;Class&lt;?&gt;&gt; WRAPPER_TYPES = getWrapperTypes();

 public static boolean isWrapperType(Class&lt;?&gt; clazz)
 {
 return WRAPPER_TYPES.contains(clazz);
 }

 private static Set&lt;Class&lt;?&gt;&gt; getWrapperTypes()
 {
 Set&lt;Class&lt;?&gt;&gt; ret = new HashSet&lt;Class&lt;?&gt;&gt;();
 ret.add(Boolean.class);
 ret.add(Character.class);
 ret.add(Byte.class);
 ret.add(Short.class);
 ret.add(Integer.class);
 ret.add(Long.class);
 ret.add(Float.class);
 ret.add(Double.class);
 ret.add(Void.class);
 return ret;
 }
}
</code></pre>

blocks|key|552458|text|Integer不是原语，Class.isPrimitive()没有说谎。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|552459|entityMap^0|0|7|C|J|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

<code>Integer</code> is not a primitive, <code>Class.isPrimitive()</code> is not lying.

blocks|key|552494|text|从Java1.5和更高版本开始，有一个称为自动装箱的新特性。编译器自己做这件事。当它看到机会时，它会将原始类型转换为相应的包装器类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|552495|这里可能发生的情况是，当您声明|552496|Object+o+=+i;|code-block|syntax|javascript|552497|编译器将此语句编译为|552498|Object+o+=+Integer.valueOf(i);|552499|这是自动装箱。这将解释您正在接收的输出。This+page+from+the+Java+1.5+spec+explains+auto-boxing+more+in+detail.|offset|length|552500|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html^0|0|0|0|0|0|K|1X|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

Starting in Java 1.5 and up, there is a new feature called auto-boxing. The compiler does this itself. When it sees an opportunity, it converts a primitive type into its appropriate wrapper class.

What is probably happening here is when you declare

<pre><code>Object o = i;
</code></pre>

The compiler will compile this statement as saying

<pre><code>Object o = Integer.valueOf(i);
</code></pre>

This is auto-boxing. This would explain the output you are receiving. <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html" rel="nofollow noreferrer">This page from the Java 1.5 spec explains auto-boxing more in detail.</a>

blocks|key|3773232|text|我认为这是由于自动装箱造成的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3773233|int+i+=+3;
Object+o+=+i;
o.getClass().getName();+//+prints+Integer|code-block|syntax|javascript|3773234|您可以实现一个实用程序方法，该方法与这些特定的装箱类相匹配，并告诉您某个类是否为原始类。|3773235|public+static+boolean+isWrapperType(Class<?>+clazz)+{
++++return+clazz.equals(Boolean.class)+%7C%7C+
++++++++clazz.equals(Integer.class)+%7C%7C
++++++++clazz.equals(Character.class)+%7C%7C
++++++++clazz.equals(Byte.class)+%7C%7C
++++++++clazz.equals(Short.class)+%7C%7C
++++++++clazz.equals(Double.class)+%7C%7C
++++++++clazz.equals(Long.class)+%7C%7C
++++++++clazz.equals(Float.class);
}|3773236|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think this happens due to auto-boxing.

<pre><code>int i = 3;
Object o = i;
o.getClass().getName(); // prints Integer
</code></pre>

You may implement a utility method that matches these specific boxing classes and gives you if a certain class is primitive.

<pre><code>public static boolean isWrapperType(Class&lt;?&gt; clazz) {
 return clazz.equals(Boolean.class) || 
 clazz.equals(Integer.class) ||
 clazz.equals(Character.class) ||
 clazz.equals(Byte.class) ||
 clazz.equals(Short.class) ||
 clazz.equals(Double.class) ||
 clazz.equals(Long.class) ||
 clazz.equals(Float.class);
}
</code></pre>

blocks|key|3773269|text|正如一些人已经说过的，这要归功于autoboxing。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3773270|您可以创建一个实用方法来检查对象的类是否是Integer、Double等。但是没有办法知道对象是否是通过自动装箱原始创建的；一旦它被装箱，它看起来就像是显式创建的对象。|style|CODE|BOLD|3773271|因此，除非你确定你的数组在没有自动装箱的情况下永远不会包含包装类，否则就没有真正的解决方案。|3773272|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html^0|G|A|0|0|L|7|T|6|13|J|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@$A|X|B|Y|F|G]|$A|Z|B|10|F|G]|$A|11|B|12|F|H]]|9|@]|C|$]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

As several people have already said, this is due to <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html" rel="nofollow noreferrer">autoboxing</a>.

You could create a utility method to check whether the object's class is <code>Integer</code>, <code>Double</code>, etc. But there is no way to know whether an object was created by autoboxing a primitive; once it's boxed, it looks just like an object created explicitly.

So unless you know for sure that your array will never contain a wrapper class without autoboxing, there is no real solution.

blocks|key|552621|text|这样您就可以看到isPrimitive有可能返回true+(因为您已经有足够的答案告诉您为什么它是false)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|552622|public+class+Main
{
++++public+static+void+main(final+String[]+argv)
++++{
++++++++final+Class+clazz;

++++++++clazz+=+int.class;
++++++++System.out.println(clazz.isPrimitive());
++++}
}|code-block|syntax|javascript|552623|当一个方法接受"int“而不是"Integer”时，这在反射中很重要。|552624|下面的代码可以工作：|552625|import+java.lang.reflect.Method;

public+class+Main
{
++++public+static+void+main(final+String[]+argv)
++++++++throws+Exception
++++{
++++++++final+Method+method;

++++++++method+=+Main.class.getDeclaredMethod("foo",+int.class);
++++}

++++public+static+void+foo(final+int+x)
++++{
++++}
}|552626|此代码失败(找不到该方法)：|552627|import+java.lang.reflect.Method;

public+class+Main
{
++++public+static+void+main(final+String[]+argv)
++++++++throws+Exception
++++{
++++++++final+Method+method;

++++++++method+=+Main.class.getDeclaredMethod("foo",+Integer.class);
++++}

++++public+static+void+foo(final+int+x)
++++{
++++}
}|552628|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Just so you can see that is is possible for isPrimitive to return true (since you have enough answers showing you why it is false):

<pre><code>public class Main
{
 public static void main(final String[] argv)
 {
 final Class clazz;

 clazz = int.class;
 System.out.println(clazz.isPrimitive());
 }
}
</code></pre>

This matters in reflection when a method takes in "int" rather than an "Integer".

This code works:

<pre><code>import java.lang.reflect.Method;

public class Main
{
 public static void main(final String[] argv)
 throws Exception
 {
 final Method method;

 method = Main.class.getDeclaredMethod("foo", int.class);
 }

 public static void foo(final int x)
 {
 }
}
</code></pre>

This code fails (cannot find the method):

<pre><code>import java.lang.reflect.Method;

public class Main
{
 public static void main(final String[] argv)
 throws Exception
 {
 final Method method;

 method = Main.class.getDeclaredMethod("foo", Integer.class);
 }

 public static void foo(final int x)
 {
 }
}
</code></pre>

blocks|key|1137426|text|primitve包装器类型不会响应此值。这是用于原语的类表示，尽管除了反射之外，我想不出它有太多的用途。举个例子|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1137427|System.out.println(Integer.class.isPrimitive());|code-block|syntax|javascript|1137428|打印"false"，但是|1137429|public+static+void+main+(String+args[])+throws+Exception
{
++++Method+m+=+Junk.class.getMethod(+"a",null);
++++System.out.println(+m.getReturnType().isPrimitive());
}

public+static+int+a()
{
++++return+1;
}|1137430|打印"true“|1137431|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The primitve wrapper types will not respond to this value. This is for class representation of primitives, though aside from reflection I can't think of too many uses for it offhand. So, for example

<pre><code>System.out.println(Integer.class.isPrimitive());
</code></pre>

prints "false", but

<pre><code>public static void main (String args[]) throws Exception
{
 Method m = Junk.class.getMethod( "a",null);
 System.out.println( m.getReturnType().isPrimitive());
}

public static int a()
{
 return 1;
}
</code></pre>

prints "true"

blocks|key|4618391|text|对于那些喜欢简洁代码的人。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4618392|private+static+final+Set<Class>+WRAPPER_TYPES+=+new+HashSet(Arrays.asList(
++++Boolean.class,+Character.class,+Byte.class,+Short.class,+Integer.class,+Long.class,+Float.class,+Double.class,+Void.class));
public+static+boolean+isWrapperType(Class+clazz)+{
++++return+WRAPPER_TYPES.contains(clazz);
}|code-block|syntax|javascript|4618393|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For those who like terse code.

<pre><code>private static final Set&lt;Class&gt; WRAPPER_TYPES = new HashSet(Arrays.asList(
 Boolean.class, Character.class, Byte.class, Short.class, Integer.class, Long.class, Float.class, Double.class, Void.class));
public static boolean isWrapperType(Class clazz) {
 return WRAPPER_TYPES.contains(clazz);
}
</code></pre>

blocks|key|3773819|text|从Spring+http://static.springsource.org/spring/docs/3.0.x/javadoc-api/获取BeanUtils|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3773820|可能Apache变体(commons+beans)具有类似的功能。|3773821|entityMap|0|LINK|mutability|MUTABLE|url|http://static.springsource.org/spring/docs/3.0.x/javadoc-api/^0|8|1P|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Get ahold of BeanUtils from Spring
 <a href="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/" rel="nofollow">http://static.springsource.org/spring/docs/3.0.x/javadoc-api/</a>

Probably the Apache variation (commons beans) has similar functionality.

blocks|key|3773864|text|commons-lang+ClassUtils有相关的方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3773865|新版本有：|3773866|boolean+isPrimitiveOrWrapped+=+
++++ClassUtils.isPrimitiveOrWrapper(object.getClass());|code-block|syntax|javascript|3773867|老版本有wrapperToPrimitive(clazz)方法，它会返回原始的对应关系。|3773868|boolean+isPrimitiveOrWrapped+=+
++++clazz.isPrimitive()+%7C%7C+ClassUtils.wrapperToPrimitive(clazz)+!=+null;|3773869|entityMap|0|LINK|mutability|MUTABLE|url|http://commons.apache.org/lang/|1|http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/ClassUtils.html^0|D|A|0|C|0|D|A|1|0|0|0|4|P|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]]]

<a href="http://commons.apache.org/lang/" rel="noreferrer">commons-lang</a> <a href="http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/ClassUtils.html" rel="noreferrer"><code>ClassUtils</code></a> has relevant methods. 

The new version has:

<pre><code>boolean isPrimitiveOrWrapped = 
 ClassUtils.isPrimitiveOrWrapper(object.getClass());
</code></pre>

The old versions have <code>wrapperToPrimitive(clazz)</code> method, which will return the primitive correspondence. 

<pre><code>boolean isPrimitiveOrWrapped = 
 clazz.isPrimitive() || ClassUtils.wrapperToPrimitive(clazz) != null;
</code></pre>

blocks|key|1137483|text|谷歌的Guava库有一个Primitives+utility，可以检查一个类是否是一个原语的包装器类型：Primitives.isWrapperType(class)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1137484|Class.isPrimitive()适用于原语|1137485|entityMap|0|LINK|mutability|MUTABLE|url|https://guava.dev/releases/snapshot-jre/api/docs/com/google/common/primitives/Primitives.html|1|https://guava.dev/releases/snapshot-jre/api/docs/com/google/common/primitives/Primitives.html#isWrapperType-java.lang.Class-^0|1G|V|C|I|0|1G|V|1|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]|$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

Google's Guava library has a <a href="https://guava.dev/releases/snapshot-jre/api/docs/com/google/common/primitives/Primitives.html" rel="nofollow noreferrer">Primitives utility</a> that check if a class is a wrapper type for a primitive: <a href="https://guava.dev/releases/snapshot-jre/api/docs/com/google/common/primitives/Primitives.html#isWrapperType-java.lang.Class-" rel="nofollow noreferrer"><code>Primitives.isWrapperType(class)</code></a>.

Class.isPrimitive() works for primitives

blocks|key|3773913|text|public+class+CheckPrimitve+{
++++public+static+void+main(String[]+args)+{
++++++++int+i+=+3;
++++++++Object+o+=+i;
++++++++System.out.println(o.getClass().getSimpleName().equals("Integer"));
++++++++Field[]+fields+=+o.getClass().getFields();
++++++++for(Field+field:fields)+{
++++++++++++System.out.println(field.getType());
++++++++}
++++}
}++

Output:
true
int
int
class+java.lang.Class
int|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3773914|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public class CheckPrimitve {
 public static void main(String[] args) {
 int i = 3;
 Object o = i;
 System.out.println(o.getClass().getSimpleName().equals("Integer"));
 Field[] fields = o.getClass().getFields();
 for(Field field:fields) {
 System.out.println(field.getType());
 }
 }
} 

Output:
true
int
int
class java.lang.Class
int
</code></pre>

blocks|key|1137522|text|这是我能想到的最简单的方法。包装器类只存在于java.lang包中。除了包装器类之外，java.lang中没有其他类具有名为TYPE的字段。你可以用它来检查一个类是否是包装类。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1137523|public+static+boolean+isBoxingClass(Class<?>+clazz)
{
++++String+pack+=+clazz.getPackage().getName();
++++if(!"java.lang".equals(pack))+
++++++++return+false;
++++try+
++++{
++++++++clazz.getField("TYPE");
++++}+
++++catch+(NoSuchFieldException+e)+
++++{
++++++++return+false;
++++}+++++++++++
++++return+true;++++++++
}|code-block|syntax|javascript|1137524|entityMap^0|M|9|17|9|1Q|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

This is the simplest way I could think of. The wrapper classes are present only in <code>java.lang</code> package. And apart from the wrapper classes, no other class in <code>java.lang</code> has field named <code>TYPE</code>. You could use that to check whether a class is Wrapper class or not.

<pre><code>public static boolean isBoxingClass(Class&lt;?&gt; clazz)
{
 String pack = clazz.getPackage().getName();
 if(!"java.lang".equals(pack)) 
 return false;
 try 
 {
 clazz.getField("TYPE");
 } 
 catch (NoSuchFieldException e) 
 {
 return false;
 } 
 return true; 
}
</code></pre>

blocks|key|1142833|text|我来晚了，但是如果你要测试一个字段，你可以使用getGenericType|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1142834|import+static+org.junit.Assert.*;

import+java.lang.reflect.Field;
import+java.lang.reflect.Type;
import+java.util.Arrays;
import+java.util.Collection;
import+java.util.HashSet;

import+org.junit.Test;

public+class+PrimitiveVsObjectTest+{

++++private+static+final+Collection<String>+PRIMITIVE_TYPES+=+
++++++++++++new+HashSet<>(Arrays.asList("byte",+"short",+"int",+"long",+"float",+"double",+"boolean",+"char"));

++++private+static+boolean+isPrimitive(Type+type)+{
++++++++return+PRIMITIVE_TYPES.contains(type.getTypeName());
++++}

++++public+int+i1+=+34;
++++public+Integer+i2+=+34;

++++@Test
++++public+void+primitive_type()+throws+NoSuchFieldException,+SecurityException+{
++++++++Field+i1Field+=+PrimitiveVsObjectTest.class.getField("i1");
++++++++Type+genericType1+=+i1Field.getGenericType();
++++++++assertEquals("int",+genericType1.getTypeName());
++++++++assertNotEquals("java.lang.Integer",+genericType1.getTypeName());
++++++++assertTrue(isPrimitive(genericType1));
++++}

++++@Test
++++public+void+object_type()+throws+NoSuchFieldException,+SecurityException+{
++++++++Field+i2Field+=+PrimitiveVsObjectTest.class.getField("i2");
++++++++Type+genericType2+=+i2Field.getGenericType();
++++++++assertEquals("java.lang.Integer",+genericType2.getTypeName());
++++++++assertNotEquals("int",+genericType2.getTypeName());
++++++++assertFalse(isPrimitive(genericType2));
++++}
}|code-block|syntax|javascript|1142835|Oracle+docs列出了8种基本类型。|1142836|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html^0|N|E|0|0|0|B|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

I'm late to the show, but if you're testing a field, you can use <code>getGenericType</code>:

<pre><code>import static org.junit.Assert.*;

import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;

import org.junit.Test;

public class PrimitiveVsObjectTest {

 private static final Collection&lt;String&gt; PRIMITIVE_TYPES = 
 new HashSet&lt;&gt;(Arrays.asList("byte", "short", "int", "long", "float", "double", "boolean", "char"));

 private static boolean isPrimitive(Type type) {
 return PRIMITIVE_TYPES.contains(type.getTypeName());
 }

 public int i1 = 34;
 public Integer i2 = 34;

 @Test
 public void primitive_type() throws NoSuchFieldException, SecurityException {
 Field i1Field = PrimitiveVsObjectTest.class.getField("i1");
 Type genericType1 = i1Field.getGenericType();
 assertEquals("int", genericType1.getTypeName());
 assertNotEquals("java.lang.Integer", genericType1.getTypeName());
 assertTrue(isPrimitive(genericType1));
 }

 @Test
 public void object_type() throws NoSuchFieldException, SecurityException {
 Field i2Field = PrimitiveVsObjectTest.class.getField("i2");
 Type genericType2 = i2Field.getGenericType();
 assertEquals("java.lang.Integer", genericType2.getTypeName());
 assertNotEquals("int", genericType2.getTypeName());
 assertFalse(isPrimitive(genericType2));
 }
}
</code></pre>

The <a href="http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html" rel="nofollow">Oracle docs</a> list the 8 primitive types.

blocks|key|552934|text|您可以通过以下语句来确定对象是否为包装器类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|552935|***objClass.isAssignableFrom(Number.class);***|code-block|syntax|javascript|552936|您还可以通过使用isPrimitive()方法来确定一个原始对象|552937|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

you could determine if an object is wrapper type by beneath statements:

<pre><code>***objClass.isAssignableFrom(Number.class);***
</code></pre>

and you could also determine a primitive object by using the isPrimitive() method

blocks|key|552939|text|public+static+boolean+isValidType(Class<?>+retType)
{
++++if+(retType.isPrimitive()+&&+retType+!=+void.class)+return+true;
++++if+(Number.class.isAssignableFrom(retType))+return+true;
++++if+(AbstractCode.class.isAssignableFrom(retType))+return+true;
++++if+(Boolean.class+==+retType)+return+true;
++++if+(Character.class+==+retType)+return+true;
++++if+(String.class+==+retType)+return+true;
++++if+(Date.class.isAssignableFrom(retType))+return+true;
++++if+(byte[].class.isAssignableFrom(retType))+return+true;
++++if+(Enum.class.isAssignableFrom(retType))+return+true;
++++return+false;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|552940|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static boolean isValidType(Class&lt;?&gt; retType)
{
 if (retType.isPrimitive() &amp;&amp; retType != void.class) return true;
 if (Number.class.isAssignableFrom(retType)) return true;
 if (AbstractCode.class.isAssignableFrom(retType)) return true;
 if (Boolean.class == retType) return true;
 if (Character.class == retType) return true;
 if (String.class == retType) return true;
 if (Date.class.isAssignableFrom(retType)) return true;
 if (byte[].class.isAssignableFrom(retType)) return true;
 if (Enum.class.isAssignableFrom(retType)) return true;
 return false;
}
</code></pre>

blocks|key|552961|text|对于javapoet的用户，也有这样的方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|552962|private+boolean+isBoxedPrimitive(Class<?>+type)+{
++++return+TypeName.get(type).isBoxedPrimitive();
}|code-block|syntax|javascript|552963|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/square/javapoet/^0|2|8|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

For users of <a href="https://github.com/square/javapoet/" rel="nofollow noreferrer">javapoet</a>, there's also this way:

<pre class="lang-java prettyprint-override"><code>private boolean isBoxedPrimitive(Class&lt;?&gt; type) {
 return TypeName.get(type).isBoxedPrimitive();
}
</code></pre>

I have an <code>Object[]</code> array, and I am trying to find the ones that are primitives. I've tried to use <code>Class.isPrimitive()</code>, but it seems I'm doing something wrong:

<pre><code>int i = 3;
Object o = i;

System.out.println(o.getClass().getName() + ", " +
 o.getClass().isPrimitive());
</code></pre>

prints <code>java.lang.Integer, false</code>.

Is there a right way or some alternative?

Determining if an Object is of primitive type

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个Object[]数组，并且我正在尝试寻找那些是基本类型的数组。我试过使用Class.isPrimitive()，但似乎做错了什么：int i = 3;Object o = i;System.out.println(o.getClass().getName() + ", " +                  ...

问确定对象是否为基元类型
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问确定对象是否为基元类型EN