HashMap -双列集合的遍历与常用的方法

package cn.learn.Map;
/*
java.util.Hashtable<k,y> implements Map<k,v>
早期双列集合，jdk1.0开始
同步的，单线程，安全，慢，底层也是哈希表
与HashMap不一样的是，Hashtable key，value不允许存储null
 
Hashtable与vector一样被多线程集合HashMap和ArrayList取代
 
但是Hashtable的子类Properties依然活跃，它是唯一一个与I/O流相结合的集合
 
 */
public class HashtableClass {
}

 package cn.learn.Map;
 
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 
 /*
  java.util.LinkedHashMap<k,v> extends HashMap
  底层原理：
     哈希表+链表(记录元素的顺序)
  */
 public class LinkedHashMapClass {
     public static void main(String[] args) {
         HashMap<String,String> map= new HashMap<>();
         map.put("a","b");
         map.put("3a","b");
         map.put("2a","b");
         map.put("1a","b");
         System.out.println(map);  //key不重复且无序
 
         LinkedHashMap<String,String> linked = new LinkedHashMap<>();
         linked.put("a","b");
         linked.put("3a","b");
         linked.put("2a","b");
         linked.put("1a","b");
         System.out.println(linked);  //有序且不重复，存取一致
     }
 
 }

 package cn.learn.Map;
 
 import java.security.Key;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
 /*
 java.util.Map1<k,v>  -双列集合
     一个元素包含两个值（一个key，一个value），key不能重合
     Map中key和value的数据类型可以相同，也可以不同
 
 java.util.HashMap<k,v>集合 implements Mqp<k,v>接口
 HashMap集合的特点
     1.HashMap集合底层是哈希表:查询的速度特别的快
     2.存储的元素和取出元素的顺序可能不一致
     3.底层是：数组+单向链表/红黑树 = 哈希表
 
 java.util.LinkedHashMap<k,v> extends HashMap<k,v>
  LinkedHashMap的特点：
     1.存取元素的顺序一致
     2.哈希表+链表（保证迭代顺序）
 
     HashMap存储自定义类型键值
     Map为了保证唯一性，需要重写hashCode和equals方法，以保证key唯一
     和HashSet一样，value可不唯一
 
  */
 public class MapMethods {
     public static void main(String[] args) {
         show1();
     }
     private static void show1(){
         HashMap<String,String> hashMap = new HashMap<>();
         //put添加集合元素，若key不在，返回value为空，若存在替换value，返回被替换的value
         System.out.println(hashMap.put("1","da"));  //返回null
 
         System.out.println(hashMap.put("1","da2"));  //返回被替换的值da
 
         System.out.println(hashMap);  //打印了不是地址，说明重写了toString方法{1=da2}
 
         //remove(Object key)删除元素，存在返回删除的value，不存在返回null
         String remove = hashMap.remove("1");
         System.out.println(remove);  //da2
 
         //get(Object key)获取value
         //containsKey(Object key)判断是否包含指定的键
         // 包含返回true不包含返回false，和遍历一起使用进行筛选
 
         //遍历双列集合
         System.out.println(hashMap.put("2","da29"));
         System.out.println(hashMap.put("5","da42"));
         System.out.println(hashMap.put("26","5da2"));
 
         //KeySet()实际是把Key值取出放入Set<key>集合（不允许重复），则可用迭代器，增强for
         Iterator<String> iter=hashMap.keySet().iterator();  //此时Set放入的是key值，迭代的也是key值
         while(iter.hasNext()){
            String k= iter.next();
             System.out.println(hashMap.get(k));
         }
         //增强for遍历
         for (String str : hashMap.keySet()) {
             System.out.println(hashMap.get(str));
         }
 
         /*
            entrySet遍历
           在Map集合中有个内部接口Entry，Map.Entry<k,v>
           作用：当Map集合一创建，就会有个Entry对象（键与值的映射关系），放入Set中
           返回类型 Set<Map.Entry<K,V>>，再调用Set的iterator方法，使用迭代器，取出Map.Entry<Object，Object>
           再调用Entry的两个方法遍历
           Map.Entry有两个方法，getKey和getValue
          */
         //放入Set
         Set<Map.Entry<String,String>> set = hashMap.entrySet();
         //使用迭代器
         Iterator<Map.Entry<String,String>> it = set.iterator();
         //利用迭代器方法遍历
         while(it.hasNext()){
             //取得Set的元素
             Map.Entry<String,String> entry= it.next();
             //调用 Map.Entry的方法
             System.out.println(entry.getKey());
             System.out.println(entry.getValue());
         }//当然可以也可以使用增强for循环
 
     }
 }