FULL PRODUCT VERSION :
java version "1.8.0_65"
Java(TM) SE Runtime Environment (build 1.8.0_65-b17)
Java HotSpot(TM) 64-Bit Server VM (build 25.65-b01, mixed mode)

ADDITIONAL OS VERSION INFORMATION :
14.5.0 Darwin Kernel Version 14.5.0: Wed Jul 29 02:26:53 PDT 2015; root:xnu-2782.40.9~1/RELEASE_X86_64 x86_64

A DESCRIPTION OF THE PROBLEM :
Dear guys,

we're facing weird issues with how HashMap behaves since java 8.

When HashMap keys implement Comparable interface but compareTo implementation is inconsistent with equals then HashMaps:
* grow much larger then they are supposed to grow
* they contain several instances of equal elements
* values attached to those elements might differ
* get(key) result depends on which key is used (even if the keys are equal according to equals method).

I've created a small test to reproduce the problem (see below). The test always passes with Java 7 (and probably previous versions). The test always fails with Java 8 (unless I remove Comparable interface from the class).

I'm not sure how fixable this is and if it's not would it be possible to explicitly underline in javadoc that compareTo MUST be consistent with equals if the objects are to be used in hash-collections.

Best regards,
Vera Tatarinova

REGRESSION. Last worked in version 7u80

ADDITIONAL REGRESSION INFORMATION:
java version "1.7.0_80"
Java(TM) SE Runtime Environment (build 1.7.0_80-b15)
Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)


STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
See source code below. It uses no external libraries but junit-4.

EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
See test above. All tests should be green (and they are in java 7). In addition if I remove "implements Comparable" then the tests are green even with java 8.
ACTUAL -
All tests are failing.

REPRODUCIBILITY :
This bug can be reproduced always.

---------- BEGIN SOURCE ----------
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;

import java.util.HashMap;
import java.util.Map;

import org.junit.Before;
import org.junit.Test;

public class HashMapTest {
    private static final char MIN_NAME = 'A';
    private static final char MAX_NAME = 'K';
    private static final int EXPECTED_NUMBER_OF_ELEMENTS = MAX_NAME - MIN_NAME + 1;
    
    private HashMap<Person, Integer> personToAgeMap;
    
    @Before
    public void before() {
        personToAgeMap = new HashMap<>();
    }
    
    @Test
    public void whenOverridingEqualElements_thenSizeOfTheMapIsStable() {
        assertEquals(0, personToAgeMap.size());
        
        putAllPeopleWithAge(personToAgeMap, 1);
        assertEquals(EXPECTED_NUMBER_OF_ELEMENTS, personToAgeMap.size());
        
        putAllPeopleWithAge(personToAgeMap, 100);
        assertEquals("Size of the map " + personToAgeMap + " is wrong: ", EXPECTED_NUMBER_OF_ELEMENTS,
                personToAgeMap.size());
    }
    
    @Test
    public void whenGettingElementUsingPersonOfAge1_thenOverridenValuesAreReturned() {
        putAllPeopleWithAge(personToAgeMap, 1);
        //overriding ages to be 100
        putAllPeopleWithAge(personToAgeMap, 100);
        
        //expecting that all ages are 100
        useAgeToCheckAllHashMapValuesAre(1, 100);
    }
    
    @Test
    public void whenGettingElementUsingPersonOfAge100_thenOverridenValuesAreReturned() {
        putAllPeopleWithAge(personToAgeMap, 1);
        putAllPeopleWithAge(personToAgeMap, 100);
        
        useAgeToCheckAllHashMapValuesAre(100, 100);
    }
    
    @Test
    public void whenGettingElementUsingPersonOfAge50_thenOverridenValuesAreReturned() {
        putAllPeopleWithAge(personToAgeMap, 1);
        putAllPeopleWithAge(personToAgeMap, 100);
        
        useAgeToCheckAllHashMapValuesAre(50, 100);
    }
    
    @Test
    public void whenGettingElementUsingPersonOfAgeMinus1_thenOverridenValuesAreReturned() {
        putAllPeopleWithAge(personToAgeMap, 1);
        putAllPeopleWithAge(personToAgeMap, 100);
        
        useAgeToCheckAllHashMapValuesAre(-10, 100);
    }
    
    private void useAgeToCheckAllHashMapValuesAre(int age, Integer expectedValue) {
        StringBuilder sb = new StringBuilder();
        
        int count = countAllPeopleUsingAge(personToAgeMap, age);
        if (EXPECTED_NUMBER_OF_ELEMENTS != count) {
            sb.append("Size of the map ").append(getAllPeopleUsingAge(personToAgeMap, age)).append(" is wrong: ")
                .append("expected <").append(EXPECTED_NUMBER_OF_ELEMENTS).append("> actual <").append(count).append(">.\n");
        }
        
        for (char name = MIN_NAME; name <= MAX_NAME; name++) {
            Person key = new Person(name, age);
            Integer value = personToAgeMap.get(key);
            if (!expectedValue.equals(value)) {
                sb.append("Unexpected value for ").append(key).append(": ")
                .append("expected <").append(expectedValue).append("> actual <").append(value).append(">.\n");
            }
        }
        
        if (sb.length() > 0) {
            sb.append("HashMap was ").append(personToAgeMap);
            fail(sb.toString());
        }
    }
    
    static void putAllPeopleWithAge(Map<Person, Integer> map, int age) {
        for (char name = MIN_NAME; name <= MAX_NAME; name++) {
            map.put(new Person(name, age), age);
        }
    }
    
    static int countAllPeopleUsingAge(Map<Person, Integer> map, int age) {
        int counter = 0;
        for (char name = MIN_NAME; name <= MAX_NAME; name++) {
            if (map.containsKey(new Person(name, age))) {
                counter++;
            }
        }
        return counter;
    }
    
    static String getAllPeopleUsingAge(Map<Person, Integer> map, int age) {
        StringBuilder sb = new StringBuilder();
        for (char name = MIN_NAME; name <= MAX_NAME; name++) {
            Person key = new Person(name, age);
            sb.append(key).append('=').append(map.get(key)).append('\n');
        }
        return sb.toString();
    }
    
    static class Person implements Comparable<Person> {
        char name;
        int age;
        
        public Person(char name, int age) {
            this.name = name;
            this.age = age;
        }
        
        //Making sure all elements end up in the very same bucket
        //Nothing wrong with it except performance...
        @Override
        public int hashCode() {
            return 0;
        }
        
        //equals is only by name
        @Override
        public boolean equals(Object other) {
            Person otherPerson = (Person)other;
            return this.name == otherPerson.name;
        }
        
        public String toString() {
            return name + "[age=" + age + "]";
        }
        
        //comparing by age
        //NOTE: compareTo is inconsistent with equals which should be OK in non-sorted collections
        //https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html
        @Override
        public int compareTo(Person other) {
            return this.age - other.age;
        }
    }
}

---------- END SOURCE ----------

CUSTOMER SUBMITTED WORKAROUND :
Use external Comparator class.