What is LinkedHashMap<k, v>?

Ok so i am new to these HashMaps but have some idea about LinkedLists and HashMaps. It would be gr开发者_JAVA技巧eat if you could give me some simple explanation regarding LinkedHashMap and as in the titile does this mean we are explicitly defining it to be of some type?

A LinkedHashMap is a combination of hash table and linked list. It has a predictable iteration order (a la linked list), yet the retrieval speed is that of a HashMap. The order of the iteration is determined by the insertion order, so you will get the key/values back in the order that they were added to this Map. You have to be a bit careful here, since re-inserting a key does not change the original order.

k stand for Key and v for Value.

/*
  Simple Java LinkedHashMap example
  This simple Java Example shows how to use Java LinkedHashMap.
  It also describes how to add something to LinkedHashMap and how to
  retrieve the value added from LinkedHashMap.
*/

import java.util.LinkedHashMap;

public class JavaLinkedHashMapExample {

public static void main(String[] args) {

//create object of LinkedHashMap
LinkedHashMap lHashMap = new LinkedHashMap();

/*
  Add key value pair to LinkedHashMap using
  Object put(Object key, Object value) method of Java LinkedHashMap class,
  where key and value both are objects
  put method returns Object which is either the value previously tied
  to the key or null if no value mapped to the key.
  */

lHashMap.put("One", new Integer(1));
lHashMap.put("Two", new Integer(2));

/*
  Please note that put method accepts Objects. Java Primitive values CAN NOT
  be added directly to LinkedHashMap. It must be converted to corrosponding
  wrapper class first.
  */

//retrieve value using Object get(Object key) method of Java LinkedHashMap class
Object obj = lHashMap.get("One");
System.out.println(obj);

/*
  Please note that the return type of get method is an Object. The value must
  be casted to the original class.
  */


}
}
/*
Output of the program would be
1
*/

It is a hybrid of two data structures, a LinkedList, where insertion order is preserved by adding elements to the end of a list of nodes which have access to their immediate neighbours, and a HashMap, or a Map that uses an array of bucket Lists, where a modulus division remainder of the key's hashcode() determines the starting bucket to query for the equals() method of the keys that lie in that bucket's list of contents.

The advantage is that you can walk the existing elements in a HashMap in order of insertion, due to the LinkedList nature, and you can quickly jump to the correct bucket in a key lookup (saving a lot of time for a large collection) if you have the key of the element.

This is called generics. k and v must be replaced with the actual type you want to store. To create a HashMap that maps integers on strings you would write:

 LinkedHashMap<Integer,String>

LinkedHashMap keys are similar to ArrayLists or arrays in the way they are stored in the order that they are inserted. Normal HashMaps are sorted by their hash code.

k = key v = value They can be any type.

The biggest difference is LinkedHashMap is ordered. If you use an iterator the keys and values will be in the same order they were added to the map. HashMap has no guarantee of the order they are returned.

Read about Generics in Java on Wikipedia.