Hashtable, HashMap, Linkedhashmap in Java

In front of the list of arrlist and linkedlist the difference is not below, the time to summarize some of the map of the class.

I. Overview

First of all, the introduction of three map (TreeMap is very special, temporarily ignored)

1, Hashtable: Array + single-linked list structure, thread safety (operation locking), unordered,

2, HashMap: Array + single-linked list structure, thread unsafe, unordered,

3, Linkedhashmap: Inherit the HashMap, array + single-linked list structure, thread unsafe, orderly (1, insert order 2, LRU: least recent access order [with two-way list storage order])

The above is the general characteristics of the three map, then how these features are implemented, we can cut from several aspects of the source code analysis of three different: constructors, put method, get method,

Second, the bottom structure

1, HashTable: When storing a value, the key is calculated according to the table array in the lower corner subscript I, if table[i] is empty, directly into the generated entry, if not empty from the entry head of the location, if the key is the same, the value is overwritten, If there is no entry of the same key, the newly generated entry is placed in the header of the lower corner of the array;

/**
* Hashtable is used to store data in an array, the elements in the array are entry, as described below. */    Private transientEntry<k,v>[] table; /*** The element in the Hashtable array is entry, which is the structure of a key and value (method omitted in class)*/    Private Static classEntry<k,v>ImplementsMap.entry<k,v> {
The hash value of the current entryintHash;
Key value of the current entryFinalK Key;
The value of the current enry, V values;
The next Entry of the current Entry (as can be seen here is a single-linked list) Entry<K,V>Next;
    }

2, HashMap: With the Hashtable exactly the same bottom structure

    /*** An empty entry array*/    Static Finalentry<?,? >[] empty_table = {}; /*** As with Hashtable, table arrays, which hold entry objects, differ only by initializing them directly to an empty array*/    transiententry<k,v>[] Table = (entry<k,v>[]) empty_table; The entry object is exactly the same as entry .Static classEntry<k,v>ImplementsMap.entry<k,v> {        FinalK Key;        V value; Entry<K,V>Next; intHash;    }

3, Linkedhashmap: The following code can be seen, Linkedhashmap inherited the HashMap, on the basis of HashMap added hear doubly linked list and entry in the front and back tags

 Public classLinkedhashmap<k,v>extendsHashmap<k,v>ImplementsMap<k,v>{      /*** The class shows that HashMap is inherited, so the underlying data grid uses the HashMap table directly.
This hear is a linked list, head for the list of heads, followed by*/    Private transientEntry<k,v>header; /*** Accessorder attribute: Used to mark whether the hear doubly linked list is to eradicate the LRU sort or the order of insertions     */    Private Final BooleanAccessorder; }

/**      * entry in Linkedhashmap inherits Enry     */    privatestatic in HashMap Classextends hashmap.entry<k,v> {        //  Two more properties: Entry before and after Entry, This is the        entry<k,v> before for head , after;     }

Iii. constructors (only for large processes)

1, Hashtable

* Most commonly used constructors, here called the This constructor, passed two parameters 11 and 0.75, the following describes the significance of the parameter*/     PublicHashtable () { This(One, 0.75f); }    /*** As you can see, the first parameter is the initial capacity is small, here the default is set to 11, the second parameter is the expansion factor, by default when the container is 75 used when the expansion*/     PublicHashtable (intInitialcapacity,floatloadfactor) {
Check capacity setting sizeif(Initialcapacity < 0)            Throw NewIllegalArgumentException ("Illegal capacity:" +initialcapacity);
Check load factor sizeif(loadfactor <= 0 | |Float.isnan (loadfactor))Throw NewIllegalArgumentException ("Illegal Load:" +loadfactor); if(initialcapacity==0) initialcapacity= 1;  This. Loadfactor =Loadfactor;
Initialize the entry array based on the initial capacity size (remember that the Hashtable is initialized when the attribute is defined above) Table=NewEntry[initialcapacity];
Calculate the critical value of expansion: Total capacity * load factor threshold= (int) math.min (initialcapacity * loadfactor, max_array_size + 1);
Calculates the Hashseed parameter, which is used to calculate the hash value of the element key inithashseedasneeded (initialcapacity); }

can see:

1, hashtable default initialization size is 11, the default expansion load factor is 0.75

2. The Hashtable array container is completed at initialization time

2, HashMap

    /*** Code optimization is done here, using constants, passing in two parameters: 16 and 0.75*/     PublicHashMap () { This(default_initial_capacity, default_load_factor); }    /*** Initial capacity is not the same as Hashtable, here is 16, loading factor is 0.75 * capacity and load factor.*/     PublicHashMap (intInitialcapacity,floatloadfactor) {
Check initial capacityif(Initialcapacity < 0)            Throw NewIllegalArgumentException ("Illegal initial capacity:" +initialcapacity); if(Initialcapacity >maximum_capacity) initialcapacity=maximum_capacity; if(loadfactor <= 0 | |Float.isnan (loadfactor))Throw NewIllegalArgumentException ("Illegal load factor:" +Loadfactor);
Set load factor and initial capacity value This. Loadfactor =Loadfactor; Threshold=initialcapacity;
This method is empty, you can see that the HashMap just set the initial value, and did not calculate the same as Hashtable, to the current position table array or an empty array
(In fact, HashMap is the first time put into the element, only the capacity of the HashMap and other information to initialize, see below) init (); }

Here you can see what the HashMap constructor does:

1, HashMap container, default capacity 16, expansion load factor 0.75

2. The constructor only makes the parameter check and parameter setting, and does not set the table to the true size, nor does it calculate the capacity critical value of the expansion.

3, Linkedhashmap

    /**      * The constructor of the fully multiplexed HashMap. The Accessorder property is set to False by default: The Hear list is sorted     in order of insertion *      /Public Linkedhashmap () {         Super();         false ;    }

Linkedhashmap Nothing to say, exactly like HashMap, more than a head list of the sort settings.

Iv. Put method

1, Hashtable

　　

　　

　　　　

　　　　

Hashtable, HashMap, Linkedhashmap in Java