在equals方法上使用isAssignableFrom时重写hashCode

Question

我需要找到一种方法来缓存方法(java.lang.reflect.Method)以这样一种方式，即每当我调用类(Class) methodName(String)和参数(T[])函数时，该函数将返回缓存的方法，如果存在或找到该方法，将其添加到缓存并返回。

我想使用HashMap进行缓存，这样我就可以在O(1)中找到方法，但问题是，当我覆盖equals方法时，我需要使用isAssignableFrom:

public class A1 extends AParent {}
public class A2 extends AParent {}
public class AParent {}
public class Temp{
    public void testFunc(AParent a){}
}

这是我在HashMap中使用的键的类:

import java.util.Arrays;
class MethodAbs{
Class c;
String methodName;
Class<?>[] argsTypes;
public MethodAbs(Class c, String methodName, Class<?>[] argsTypes){
    this.c = c;
    this.methodName = methodName;
    this.argsTypes = argsTypes;
}
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    MethodAbs methodAbs = (MethodAbs) o;
    if (c != null ? !c.equals(methodAbs.c) : methodAbs.c != null) return false;
    if (methodName != null ? !methodName.equals(methodAbs.methodName) : methodAbs.methodName != null)
        return false;
    return isArgsTypesEq(argsTypes, methodAbs.argsTypes);
}
//a method is equals to the one cached if the arguments types
// can be cast to the ones that are saved on the map,
// i.e the ones on the method declaration 
private boolean isArgsTypesEq(Class<?>[] at1, Class<?>[] at2){
    boolean res = at1.length == at2.length;
    for(int i = 0; i<at1.length && res; i++){
        if(!at1[i].isAssignableFrom(at2[i])) res = false;
    }
    return res;
}

//default implementation (not working properly!)
@Override
public int hashCode() {
    int result = c != null ? c.hashCode() : 0;
    result = 31 * result + (methodName != null ? methodName.hashCode() : 0);
    result = 31 * result + Arrays.hashCode(argsTypes);
    return result;
}

}

用于缓存

的类

class Run{
public Map<MethodAbs, Method> map = new HashMap<>();
public<T> Method myFunc(Class c, String methodName, T[] args){
    MethodAbs ma = new MethodAbs(c, methodName, getTypes(args));
    if(map.containsKey(ma)){
        return map.get(ma);
    }
    else{
        for(Method method: c.getMethods()){
            MethodAbs currMethodAbs = new MethodAbs(c, method.getName(), method.getParameterTypes());
            if(!map.containsKey(currMethodAbs))
                map.put(currMethodAbs, method);
            if(currMethodAbs.equals(ma)) break;
        }
    }
    return map.get(ma);
}
private<T> Class<?>[] getTypes(T[] args) {
    Class<?>[] types = new Class<?>[args.length];
    for(int i = 0; i< args.length; i++){
        types[i] = args[i].getClass();
    }
    return types;
}
}

And Main:

 public static void main(String[] args){
    Run r = new Run();
    Object [] arr = new Object[1];
    arr[0] = new A1();
    r.myFunc(Temp.class, "testFunc", arr);
    arr[0] = new A2();
    r.myFunc(Temp.class, "testFunc", arr);
}

在上面的场景中，第一次调用r.myFunc之后，映射看起来是这样的:

MethodAbs(Temp.class, "testFunc", [AParent.class]) 

在第二个时间图上。containsKey将返回false(因为是parent。= A2.hashCode)，但它们是equals .

• 示例中显示的层次结构不一定是这样的(例如A2可以是parent的孙子)

我知道我可以使用类和方法名称作为键和值将是一个方法列表，我需要迭代和比较相等，但我试图找到一个更好的方法…

Answer 1

不幸的是，您的equals方法从根本上是坏的，至少有两个原因。

1. 它不是对称的，参见以下代码片段:

   public static void main(String... args) {
       MethodAbs methodValueOfObject = new MethodAbs(String.class, "valueOf", new Class<?>[] { Object.class });
       MethodAbs methodValueOfCharArrays = new MethodAbs(String.class, "valueOf", new Class<?>[] { char[].class });
       System.out.println(methodValueOfObject.equals(methodValueOfCharArrays)); // prints "true"
       System.out.println(methodValueOfCharArrays.equals(methodValueOfObject)); // prints "false"
   }
   

2. 它等同于你可能不想被认为是相等的方法。为了理解这一点，假设您的Temp类有两个testFunc方法，public void testFunc(A1 a)和public void testFunc(A2 a)。对应的MethodAbs对象不应该是相等的，但根据你的实现，它们确实是相等的。

我认为对你来说最好的解决方案是完全摆脱缓存。只使用

public Method getMethod(Class<?> c, String methodName, Class<?>... paramClasses) {
    try {
        return c.getDeclaredMethod(methodName, paramClasses);
    } catch (NoSuchMethodException | SecurityException e) {
        // Your exception handling goes here
        return null;
    }
}

Class对象已经被类加载器缓存，所以性能损失可以忽略不计。