equals和hashCode源码解析

2

3

4

public native int hashCode();

public boolean equals(Object obj) {

        return (this == obj);

    }

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

/**

* 关注点1

     * Returns a hash code value for the object. This method is

     * supported for the benefit of hash tables such as those provided by

     * {@link java.util.HashMap}.

     * <p>

     * The general contract of {@code hashCode} is:

     * <ul>

     * <li>Whenever it is invoked on the same object more than once during

     *     an execution of a Java application, the {@code hashCode} method

     *     must consistently return the same integer, provided no information

     *     used in {@code equals} comparisons on the object is modified.

     *     This integer need not remain consistent from one execution of an

     *     application to another execution of the same application.

* 关注点2

     * <li>If two objects are equal according to the {@code equals(Object)}

     *     method, then calling the {@code hashCode} method on each of

     *     the two objects must produce the same integer result.

     * <li>It is <em>not</em> required that if two objects are unequal

     *     according to the {@link java.lang.Object#equals(java.lang.Object)}

     *     method, then calling the {@code hashCode} method on each of the

     *     two objects must produce distinct integer results.  However, the

     *     programmer should be aware that producing distinct integer results

     *     for unequal objects may improve the performance of hash tables.

     * </ul>

     * <p>

* 关注点3

     * As much as is reasonably practical, the hashCode method defined by

     * class {@code Object} does return distinct integers for distinct

     * objects. (This is typically implemented by converting the internal

     * address of the object into an integer, but this implementation

     * technique is not required by the

     * Java<font size="-2"><sup>TM</sup></font> programming language.)

     *

     * @return  a hash code value for this object.

     * @see     java.lang.Object#equals(java.lang.Object)

     * @see     java.lang.System#identityHashCode

     */

    public native int hashCode();

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

public class Person {

    private String name;

    private int age;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    @Override

    public boolean equals(Object obj) {

        if(!(obj instanceof Person)){

            return false;

        }

        Person tmp=(Person)obj;

        return name.equals(tmp.getName()) && age==tmp.getAge();

    }

}

2

static final Entry<?,?>[] EMPTY_TABLE = {};

    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

static class Entry<K,V> implements Map.Entry<K,V> {

        final K key;

        V value;

        Entry<K,V> next;

        int hash;

        /**

         * Creates new entry.

         */

        Entry(int h, K k, V v, Entry<K,V> n) {

            value = v;

            next = n;

            key = k;

            hash = h;

        }

        //略

}

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

public V put(K key, V value) {

        if (table == EMPTY_TABLE) {

            inflateTable(threshold);

        }

        if (key == null)

            return putForNullKey(value);

        int hash = hash(key);

        int i = indexFor(hash, table.length);

        for (Entry<K,V> e = table[i]; e != null; e = e.next) {

            Object k;

            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {

                V oldValue = e.value;

                e.value = value;

                e.recordAccess(this);

                return oldValue;

            }

        }

        modCount++;

        addEntry(hash, key, value, i);

        return null;

    }

2

3

4

5

6

7

8

9

10

11

12

13

14

final int hash(Object k) {

        int h = hashSeed;

        if (0 != h && k instanceof String) {

            return sun.misc.Hashing.stringHash32((String) k);

        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by

        // constant multiples at each bit position have a bounded

        // number of collisions (approximately 8 at default load factor).

        h ^= (h >>> 20) ^ (h >>> 12);

        return h ^ (h >>> 7) ^ (h >>> 4);

    }

2

3

static int indexFor(int h, int length) {

        return h & (length-1);

    }

2

3

4

5

6

7

public V get(Object key) {

        if (key == null)

            return getForNullKey();

        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();

    }

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

final Entry<K,V> getEntry(Object key) {

        if (size == 0) {

            return null;

        }

        int hash = (key == null) ? 0 : hash(key);

        for (Entry<K,V> e = table[indexFor(hash, table.length)];

             e != null;

             e = e.next) {

            Object k;

            if (e.hash == hash &&

                ((k = e.key) == key || (key != null && key.equals(k))))

                return e;

        }

        return null;

    }

2

3

private transient HashMap<E,Object> map;

    private static final Object PRESENT = new Object();

2

3

public boolean add(E e) {

        return map.put(e, PRESENT)==null;

    }