详解HashMap的内部工作原理

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

40

41

42

43

package org.arpit.javapostsforlearning;

public class Country {

 String name;

 long population;

 public Country(String name, long population) {

  super();

  this.name = name;

  this.population = population;

 }

 public String getName() {

  return name;

 }

 public void setName(String name) {

  this.name = name;

 }

 public long getPopulation() {

  return population;

 }

 public void setPopulation(long population) {

  this.population = population;

 }

 // If length of name in country object is even then return 31(any random number) and if odd then return 95(any random number).

 // This is not a good practice to generate hashcode as below method but I am doing so to give better and easy understanding of hashmap.

 @Override

 public int hashCode() {

  if(this.name.length()%2==0)

   return 31;

  else

   return 95;

 }

 @Override

 public boolean equals(Object obj) {

  Country other = (Country) obj;

   if (name.equalsIgnoreCase((other.name)))

   return true;

  return false;

 }

}

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

import java.util.HashMap;

import java.util.Iterator;

public class HashMapStructure {

    /**

     * @author Arpit Mandliya

     */

    public static void main(String[] args) {

        Country india=new Country("India",1000);

        Country japan=new Country("Japan",10000);

        Country france=new Country("France",2000);

        Country russia=new Country("Russia",20000);

        HashMap<country,string> countryCapitalMap=new HashMap<country,string>();

        countryCapitalMap.put(india,"Delhi");

        countryCapitalMap.put(japan,"Tokyo");

        countryCapitalMap.put(france,"Paris");

        countryCapitalMap.put(russia,"Moscow");

        Iterator<country> countryCapitalIter=countryCapitalMap.keySet().iterator();//put debug point at this line

        while(countryCapitalIter.hasNext())

        {

            Country countryObj=countryCapitalIter.next();

            String capital=countryCapitalMap.get(countryObj);

            System.out.println(countryObj.getName()+"----"+capital);

            }

        }

}

2

3

4

5

6

7

8

static class Entry implements Map.Entry

{

        final K key;

        V value;

        Entry next;

        final int hash;

        ...//More code goes here

}   `

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

/**

  * Associates the specified value with the specified key in this map. If the

  * map previously contained a mapping for the key, the old value is

  * replaced.

  *

  * @param key

  *            key with which the specified value is to be associated

  * @param value

  *            value to be associated with the specified key

  * @return the previous value associated with <tt>key</tt>, or <tt>null</tt>

  *         if there was no mapping for <tt>key</tt>. (A <tt>null</tt> return

  *         can also indicate that the map previously associated

  *         <tt>null</tt> with <tt>key</tt>.)

  */

 public V put(K key, V value) {

  if (key == null)

   return putForNullKey(value);

  int hash = hash(key.hashCode());

  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

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

/**

  * Returns the value to which the specified key is mapped, or {@code null}

  * if this map contains no mapping for the key.

  *

  * <p>

  * More formally, if this map contains a mapping from a key {@code k} to a

  * value {@code v} such that {@code (key==null ? k==null :

  * key.equals(k))}, then this method returns {@code v}; otherwise it returns

  * {@code null}. (There can be at most one such mapping.)

  *

  * </p><p>

  * A return value of {@code null} does not <i>necessarily</i> indicate that

  * the map contains no mapping for the key; it‘s also possible that the map

  * explicitly maps the key to {@code null}. The {@link #containsKey

  * containsKey} operation may be used to distinguish these two cases.

  *

  * @see #put(Object, Object)

  */

 public V get(Object key) {

  if (key == null)

   return getForNullKey();

  int hash = hash(key.hashCode());

  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.equals(k)))

    return e.value;

  }

  return null;

 }