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循环


    }
}