Java 8 - equals和hashcode的默认方法

Question

Java 8 - equals和hashcode的默认方法

equalsjava-8hashcodebehaviordefault-method

3

我已经在接口中创建了默认方法，用于以可预测的方式实现equals(Object)和hashCode()。我使用反射来迭代类型（类）中的所有字段，以提取值并进行比较。该代码依赖于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倍长的时间的见解也将非常有帮助。

- thomas77

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Holger · Accepted Answer

这里的default方法并没有什么特殊之处。第一次在以前未使用的类上调用方法时，调用将触发类的加载、验证和初始化，并且方法的执行将在解释模式下开始，然后JIT编译器/hotspot优化器将启动。对于一个interface，当实现它的类被初始化时，它将被加载并进行一些验证步骤，但其他步骤仍将被推迟，直到它实际被使用，在你的情况下，当第一次调用interface的default方法时。

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

请注意，你的代码是一个存在比default方法更长时间的常见反模式。 HashAndEquals与“实现”它的类之间不存在is-a关系。相反，你可以（也应该）将这两个实用方法作为static方法提供给专门的类，并使用import static如果你想调用这些方法而不必添加声明类。

从interface继承这些方法没有任何好处。毕竟，每个类都必须重写Object.hashCode和Object.equals并可以选择有意地使用这些实用程序方法或不使用。