added treemap and hashmap

Author: connectaman

.idea/workspace.xml

@@ -137,11 +137,11 @@ It is used to develop rich internet applications. It uses a light-weight user in
 |[Priority Thread](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Multithreading/Priority.md)|
 |[Daemon Thread](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Multithreading/DemonThread.md)|
 |[Swings](https://github.com/connectaman/Java_Notes_and_Programs/tree/master/src/swings)|
-|[Collections]()|
-|[ArrayList]()|
-|[LinkedList]()|
-|[HashSet]()|
-|[TreeSet]()|
+|[Collections](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Collections/Collection.md)|
+|[ArrayList](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Collections/ArrayList.md)|
+|[LinkedList](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Collections/LinkedList.md)|
+|[HashSet](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Collections/HashSet.md)|
+|[TreeSet](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Collections/TreeSet.md)|
 |[HashMap]()|
 |[TreeMap]()|
 |[]()|

README.md

@@ -0,0 +1,48 @@
+### Java HashMap class
+
+
+##### Points to remember
+
+- Java HashMap class contains values based on the key.
+- Java HashMap class contains only unique keys.
+- Java HashMap class may have one null key and multiple null values.
+- Java HashMap class is non synchronized.
+- Java HashMap class maintains no order.
+- The initial default capacity of Java HashMap class is 16 with a load factor of 0.75.
+
+
+
+---------
+
+```java
+import java.util.*;  
+public class HashMap2 {  
+   public static void main(String args[]) {  
+    HashMap<Integer,String> map=new HashMap<Integer,String>();          
+      map.put(100,"Amit");    
+      map.put(101,"Vijay");    
+      map.put(102,"Rahul");  
+      map.put(103, "Gaurav");  
+    System.out.println("Initial list of elements: "+map);  
+    //key-based removal  
+    map.remove(100);  
+    System.out.println("Updated list of elements: "+map);  
+    //value-based removal  
+    map.remove(101);  
+    System.out.println("Updated list of elements: "+map);  
+    //key-value pair based removal  
+    map.remove(102, "Rahul");  
+    System.out.println("Updated list of elements: "+map);  
+   }      
+}  
+```
+Output
+```
+Initial list of elements: {100=Amit, 101=Vijay, 102=Rahul, 103=Gaurav}
+Updated list of elements: {101=Vijay, 102=Rahul, 103=Gaurav}
+Updated list of elements: {102=Rahul, 103=Gaurav}
+Updated list of elements: {103=Gaurav}
+```
+
+---------
+

src/Collections/HashMap.md

@@ -0,0 +1,72 @@
+### Java TreeMap class
+
+
+Java TreeMap class is a red-black tree based implementation. It provides an efficient means of storing key-value pairs in sorted order.
+
+##### The important points about Java TreeMap class are:
+
+- Java TreeMap contains values based on the key. It implements the NavigableMap interface and extends AbstractMap class.
+- Java TreeMap contains only unique elements.
+- Java TreeMap cannot have a null key but can have multiple null values.
+- Java TreeMap is non synchronized.
+- Java TreeMap maintains ascending order.
+
+
+--------
+
+##### Java TreeMap Example
+
+```java
+import java.util.*;  
+class TreeMap1{  
+ public static void main(String args[]){  
+   TreeMap<Integer,String> map=new TreeMap<Integer,String>();    
+      map.put(100,"Amit");    
+      map.put(102,"Ravi");    
+      map.put(101,"Vijay");    
+      map.put(103,"Rahul");    
+        
+      for(Map.Entry m:map.entrySet()){    
+       System.out.println(m.getKey()+" "+m.getValue());    
+      }    
+ }  
+}  
+```
+Output
+```
+       100 Amit
+       101 Vijay
+       102 Ravi
+       103 Rahul
+```
+
+---------
+
+```java
+import java.util.*;  
+class TreeMap3{  
+ public static void main(String args[]){  
+   NavigableMap<Integer,String> map=new TreeMap<Integer,String>();    
+      map.put(100,"Amit");    
+      map.put(102,"Ravi");    
+      map.put(101,"Vijay");    
+      map.put(103,"Rahul");    
+      //Maintains descending order  
+      System.out.println("descendingMap: "+map.descendingMap());  
+      //Returns key-value pairs whose keys are less than or equal to the specified key.  
+      System.out.println("headMap: "+map.headMap(102,true));  
+      //Returns key-value pairs whose keys are greater than or equal to the specified key.  
+      System.out.println("tailMap: "+map.tailMap(102,true));  
+      //Returns key-value pairs exists in between the specified key.  
+      System.out.println("subMap: "+map.subMap(100, false, 102, true));   
+ }  
+} 
+```
+
+Output
+```
+descendingMap: {103=Rahul, 102=Ravi, 101=Vijay, 100=Amit}
+headMap: {100=Amit, 101=Vijay, 102=Ravi}
+tailMap: {102=Ravi, 103=Rahul}
+subMap: {101=Vijay, 102=Ravi}
+```