检查原始字段的类型

发布于 2024-08-14 05:43:16 字数 796 浏览 10 评论 0原文

我正在尝试确定对象上字段的类型。当对象传递给我时,我不知道该对象的类型,但我需要查找 long 的字段。区分装箱的 Long 很容易,但原始的 long 似乎更困难。

可以确保传递给我的对象只有Long,而不是基元,但我宁愿不这样做。所以我所拥有的是:

for (Field f : o.getClass().getDeclaredFields()) {
    Class<?> clazz = f.getType();
    if (clazz.equals(Long.class)) {
        // found one -- I don't get here for primitive longs
    }
}

一种似乎有效的黑客方法是:

for (Field f : o.getClass().getDeclaredFields()) {
    Class<?> clazz = f.getType();
    if (clazz.equals(Long.class) ||  clazz.getName().equals("long")) {
        // found one
    }
}

如果有的话,我真的很想要一种更干净的方法来做到这一点。如果没有更好的方法,那么我认为要求我收到的对象仅使用 Long (而不是 long)将是一个更好的 API。

有什么想法吗?

I'm trying to determine the type of a field on an object. I don't know the type of the object when it is passed to me but I need to find fields which are longs. It is easy enough to distinguish the boxed Longs but the primitive long seems more difficult.

I can make sure that the objects passed to me only have Longs, not the primitives, but I'd rather not. So what I have is:

for (Field f : o.getClass().getDeclaredFields()) {
    Class<?> clazz = f.getType();
    if (clazz.equals(Long.class)) {
        // found one -- I don't get here for primitive longs
    }
}

A hacky way, which seems to work, is this:

for (Field f : o.getClass().getDeclaredFields()) {
    Class<?> clazz = f.getType();
    if (clazz.equals(Long.class) ||  clazz.getName().equals("long")) {
        // found one
    }
}

I'd really like a cleaner way to do this if there is one. If there is no better way then I think that requiring the objects I receive to only use Long (not long) would be a better API.

Any ideas?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(4

生生漫 2024-08-21 05:43:16

您使用了错误的常量来检查 Long 原语 - 使用 Long.TYPE,每个其他原语类型都可以在包装器上使用类似命名的常量找到。例如:Byte.TYPECharacter.TYPE等。

You're using the wrong constant to check for Long primitives - use Long.TYPE, each other primitive type can be found with a similarly named constant on the wrapper. eg: Byte.TYPE, Character.TYPE, etc.

情场扛把子 2024-08-21 05:43:16
o.getClass().getField("fieldName").getType().isPrimitive();
o.getClass().getField("fieldName").getType().isPrimitive();
若能看破又如何 2024-08-21 05:43:16

您可以只使用

boolean.class
byte.class
char.class
short.class
int.class
long.class
float.class
double.class
void.class

如果您正在使用反射,那么您为什么要关心,为什么要进行此检查。 get/set 方法总是使用对象,因此您不需要知道该字段是否是原始类型(除非您尝试将原始类型设置为 null 值)。

事实上,对于 get() 方法,您不需要 知道该字段是否为原始类型(除非您尝试将原始类型设置为 null 值)。不需要知道它是什么类型。 做

// any number type is fine.
Number n = field.get(object);
long l = n.longValue();

如果您不确定它是否是 Number 类型,您可以这样

Object o = field.get(object); // will always be an Object or null.
if (o instanceof Number) {
     Number n = (Number) o;
     long l = n.longValue();

You can just use

boolean.class
byte.class
char.class
short.class
int.class
long.class
float.class
double.class
void.class

If you are using reflection, why do you care, why do this check at all. The get/set methods always use objects so you don't need to know if the field is a primitive type (unless you try to set a primitive type to the null value.)

In fact, for the method get() you don't need to know which type it is. You can do

// any number type is fine.
Number n = field.get(object);
long l = n.longValue();

If you are not sure if it is a Number type you can do

Object o = field.get(object); // will always be an Object or null.
if (o instanceof Number) {
     Number n = (Number) o;
     long l = n.longValue();
待天淡蓝洁白时 2024-08-21 05:43:16
  • 要检测 long 类型的字段,请使用 long.classLong.TYPE

  • 要检测 Long 类型的字段,请使用 Long.class

示例:

for (Field f : o.getClass().getDeclaredFields()) {
    Class<?> clazz = f.getType();
    // to detect both Long and long types
    if (Long.class.equals(clazz) || long.class.equals(clazz)) {
        // found one
    }
}

注意

Long.TYPE是静态常量成员,等同于long.class

片段代码形式 Long

<前><代码>/**
* 表示原始类型{@code long} 的{@link Class} 对象。
*/
@SuppressWarnings(“未选中”)
公共静态最终类<长>;类型
= (Class) long[].class.getComponentType();

另请检查 答案Integer.class 和 Integer.TYPE 之间的区别问题

  • To detect fields with long type use long.class or Long.TYPE.

  • To detect fields with Long type use Long.class.

Example:

for (Field f : o.getClass().getDeclaredFields()) {
    Class<?> clazz = f.getType();
    // to detect both Long and long types
    if (Long.class.equals(clazz) || long.class.equals(clazz)) {
        // found one
    }
}

Notice:

Long.TYPE is static Constant member and is equivalent to long.class.

snippet code form Long Class

/**
 * The {@link Class} object that represents the primitive type {@code long}.
 */
@SuppressWarnings("unchecked")
public static final Class<Long> TYPE
        = (Class<Long>) long[].class.getComponentType();

Also check for answer for Difference between Integer.class and Integer.TYPE question

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文