Question

我有一个方法，用于将参数类型与给定的参数类型进行比较。

private boolean typesMatch(Class<?>[] one, Object[] two)
{
    if(one.length != two.length)
        return false;

    for (int i = 0; (i < one.length)&&(i < two.length); i++)
        if(!one[i].equals(two[i].getClass()))
            return false;

    return true;
}

例如，在一个[]中，可能有String, boolean。但是，在第二个中，有String, Boolean。你看到我的问题了吗？当它比较布尔值和布尔值时，它返回false。我如何解决这个问题，以便我不必为每种原始类型使用'if语句'来解包它们？

编辑：我的意思是在第二个数组中打开包装类，使其与第一个数组中的基本类型相当。

最初，数组2中的Boolean对象被添加为原始布尔值。

Answer 1

这可以解决您的问题：

private static boolean typesMatch(Class<?>[] one, Object[] two)
    {
        if(one.length != two.length) {
            return false;
        }

        for (int i = 0; (i < one.length)&&(i < two.length); i++){
            if ((one[i].isPrimitive() && two[i].getClass().getSimpleName().equalsIgnoreCase(one[i].getName())) ||
                    (two[i].getClass().isPrimitive() && one[i].getSimpleName().equalsIgnoreCase(two[i].getClass().getName()))) {
                return true;
            }
            if(!one[i].equals(two[i].getClass())) {
                return false;
            }
        }

        return true;
    }

Answer 2

对于每个原语，您都不需要if语句。

检查two[i].getClass()是否是基元之一，然后调用将返回它的包装类的函数。

// safe because both Long.class and long.class are of type Class<Long>
  @SuppressWarnings("unchecked")
  private static <T> Class<T> wrap(Class<T> c) {
    return c.isPrimitive() ? (Class<T>) WRAPPERS_TO_PRIMITIVES.get(c) : c;
  }

  private static final Map<Class<?>, Class<?>> WRAPPERS_TO_PRIMITIVES
    = new ImmutableMap.Builder<Class<?>, Class<?>>()
      .put(Boolean.class, boolean.class)
      .put(Byte.class, byte.class)
      .put(Character.class, char.class)
      .put(Double.class, double.class)
      .put(Float.class, float.class)
      .put(Integer.class, int.class)
      .put(Long.class, long.class)
      .put(Short.class, short.class)
      .put(Void.class, void.class)
      .build();

以上代码取自Simple way to get wrapper class type in Java

比较参数类型

2 个答案: