Java 8-같음 및 해시 코드에 대한 기본 메서드

default구현 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) );
} 

이러한 메서드를 인터페이스에 넣는 이유는 가능한 한 유연하기 때문입니다. 내 클래스 중 일부는 상속이 필요할 수 있습니다.

내 테스트에 따르면 해시 코드와 같음 모두 동일한 내부 상태를 가진 객체에 대해 항상 동일한 값을 반환한다고 믿을 수 있습니다.

내가 알고 싶은 것은 내가 뭔가를 놓치고 있는지입니다. 그리고 이러한 방법의 동작을 신뢰할 수 있다면? ( Lombok 및 AutoValue 프로젝트가 이러한 방법을 구현하는 데 도움이 된다는 것을 알고 있지만 제 클라이언트는 이러한 라이브러리에 너무 열중하지 않습니다).

메서드 호출을 처음 수행하는 데 항상 약 5 배 더 오래 걸리는 이유에 대한 통찰력도 매우 유용 할 것입니다.