Java 8 - 用于等号和哈希码的默认方法

Question

我在用于以可预测的方式实现equals(Object)和hashCode()的接口中创建了default方法。我使用反射来迭代类型（类）中的所有字段以提取值并进行比较。代码取决于Apache Commons Lang及其HashCodeBuilder和EqualsBuilder。

问题是，我的测试显示我第一次打电话给这些方法时，第一次调用需要更多时间。计时器使用System.nanoTime()。下面是从原木的例子：

Time spent hashCode: 192444 
Time spent hashCode: 45453 
Time spent hashCode: 48386 
Time spent hashCode: 50951 

实际的代码：

public interface HashAndEquals { 

    default <T> int getHashCode(final T type) { 
     final List<Field> fields = Arrays.asList(type.getClass().getDeclaredFields()); 
     final HashCodeBuilder builder = new HashCodeBuilder(31, 7); 
     fields.forEach(f -> { 
      try { 
       f.setAccessible(true); 
       builder.append(f.get(type)); 
      } catch (IllegalAccessException e) { 
       throw new GenericException(e.toString(), 500); 
      } 
     }); 
     return builder.toHashCode(); 
    } 

    default <T, K> boolean isEqual(final T current, final K other) { 
     if(current == null || other == null) { 
      return false; 
     } 
     final List<Field> currentFields = Arrays.asList(current.getClass().getDeclaredFields()); 
     final List<Field> otherFields = Arrays.asList(other.getClass().getDeclaredFields()); 
     final IsEqual isEqual = new IsEqual(); 
     isEqual.setValue(true); 
     currentFields.forEach(c -> otherFields.forEach(o -> { 
      c.setAccessible(true); 
      o.setAccessible(true); 
      try { 
       if (o.getName().equals(c.getName())) { 
        if (!o.get(other).equals(c.get(current))) { 
         isEqual.setValue(false); 
        } 
       } 
      } catch (IllegalAccessException e) { 
       isEqual.setValue(false); 
      } 
     })); 
     return isEqual.getValue(); 
    } 
} 

如何被用来实现hashCode和equals这些方法：测试的

@Override 
public int hashCode() { 
    return getHashCode(this); 
} 

@Override 
public boolean equals(Object obj) { 
    return obj instanceof Step && isEqual(this, obj); 
} 

示例：

@Test 
public void testEqualsAndHashCode() throws Exception { 
    Step step1 = new Step(1, Type.DISPLAY, "header 1", "description"); 
    Step step2 = new Step(1, Type.DISPLAY, "header 1", "description"); 
    Step step3 = new Step(2, Type.DISPLAY, "header 2", "description"); 
    int times = 1000; 
    long total = 0; 

    for(int i = 0; i < times; i++) { 
     long start = System.nanoTime(); 
     boolean equalsTrue = step1.equals(step2); 
     long time = System.nanoTime() - start; 
     total += time; 
     System.out.println("Time spent: " + time); 
     assertTrue(equalsTrue); 
    } 
    System.out.println("Average time: " + total/times); 

    for(int i = 0; i < times; i++) { 
     assertEquals(step1.hashCode(), step2.hashCode()); 
     long start = System.nanoTime(); 
     System.out.println(step1.hashCode() + " = " + step2.hashCode()); 
     System.out.println("Time spent hashCode: " + (System.nanoTime() - start)); 
    } 
    assertFalse(step1.equals(step3)); 
} 

将这些方法放入界面的原因应尽可能灵活。我的一些类可能需要继承。

我的测试表明我可以相信hashcode和equals总是返回具有相同内部状态的对象的相同值。

我想知道的是如果我失去了一些东西。如果这些方法的行为可以信任？ （我知道项目Lombok和AutoValue为实现这些方法提供了一些帮助，但我的客户不太喜欢这些库）。

任何洞察力为什么总是需要大约5倍的时间才能第一次执行方法调用也会非常有帮助。

Answer 1

这里没有什么特别的default方法。当您第一次调用以前未使用的类的方法时，调用将触发类的加载，验证和初始化，并且在JIT编译器/热点优化器启动之前，方法的执行将以解释模式启动。在这种情况下当它的类实现初始化时，它将被加载并执行一些验证步骤，但是其他步骤仍然被延迟到实际使用时，在你的情况下interface的default方法是第一次被调用。

在Java中，这是一种正常现象，第一次执行需要比后续执行更多的时间。在你的情况下，你正在使用lambda表达式，当运行时生成功能接口实现时，会有额外的首次开销。

请注意，您的代码是一种常见的反模式，其存在时间比default方法长。关于HashAndEquals和类“实施”它之间的关系是没有的。您可以（也应该）在专用类中提供这两种实用方法作为static方法，如果要在不预先声明声明类的情况下调用这些方法，请使用import static。

从interface继承这些方法没有任何好处。毕竟，每个班级无论如何都必须重写Object.hashCode和Object.equals，并且可以故意选择是否使用这些实用方法。