引言

一Map體系的訪問方式

Map的訪問也和HashSet的特點一樣是無需的，Map體系與Set體系不同並不實現Iterator介面，當然也不會具有迭代器，那麼Map集合怎麼訪問呢？間接通過Set的迭代器，Map集合訪問方式主要有兩種：keySet和entrySet

1. keySet：將Map中所有的鍵存入到Set集合，再借助Set的迭代器Iterator取出所有的鍵，最後再根據get方法獲取到鍵對應的值。

Map<T,T> map=new HasMap<T,T>()
Set<T> set=map.keySet();//得到Set集合
Iterator<
 
T> it=set.iterator();//得到Set集合的迭代器
while(it.hasNext()){
    String key=it.next();//通過迭代器獲取鍵
    String value=map.get(key);//map根據鍵獲取對應的值
}

1. entrySet:將Map集合的對映關係Map.Entry存入到Set集合中，對映關係的資料型別就是Map.Entry。

/*
Map.Entry：其實Entry是Map介面中的一個內部介面（因為能加static修飾符只能是成員變數，所以只能是成員介面），因為只能先有Map集合才有對映關係，而對映關係是直接處理成員資料的，所以設計為內部介面。
interface Map{
    public static interface Entry{
        public abstract Object getKey();
        ...
 

    }
}
//巢狀介面的實現
class HashMaps implements Map{
    class Maps implements Map.Entry{
        public Object getKey();
        ...
    }
}*/

Set<Map.Entry<T,T>> entrySet=map.entrySet();//得到Set集合
Iterator<Map.Entry<T,T>> it=entrySet.iterator();//得到Set集合的迭代器
while(it.hasNext()){
    Map.Entry<T
 
,T> m=it.next();//通過迭代器獲取對映關係
    String key=m.getKey();//通過對映關係獲取key
    String value=map.getValue(key);
}

二Map體系集合之HashTable（已基本被HasMap替代）

雜湊表HashTable實現了Map介面，該雜湊表將鍵對映到對應的值，該集合是執行緒同步的。任何非null物件都可以作為鍵Key或者值Value，換言之不允許存入null鍵null值。為了能成功在雜湊表中儲存和獲取物件，用作鍵的物件必須實現hashCode和equals方法。

三Map體系集合之HashMap

HashMap底層資料結構也是雜湊表，除了非同步和允許使用null鍵和null值、效率比較高以外，其他功能和HashTable類相同。
要儲存到Map集合的物件完成三步工作：實現Comparable<物件>、覆寫compareTo、hashCode、equals方法，至於原因嗎，因為雜湊體系。

class  Person implements Comparable<Person>{
    private String name;
    private int age;

    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public int compareTo(Person s){
        int num=new Integer(this.age).compareTo(new Integer(s.age));
        if(num==0){
            return this.name.compareTo(s.name);
        }
        else{
            return num;
        }
    }
    //為了去除重複必須重新構造hashCOde
    public int hashCode()
    {
        return name.hasCode()+age*37;
    }

    //當雜湊值相同的時候才會執行
    public boolean equals(Object obj){
        if(!(obj instanceof Person)){
            throw new ClassCastException("型別不匹配");
        }
        Person p=(Person)obj;
        return this.name.equals(p.name) && this.age==p.age;
    }
    public String toString(){
        return "姓名："+name+"年齡："+age;
    }
}
//把Person物件儲存到HasMap中，以Person物件為鍵，對應的籍貫為值，姓名和年齡相同就認為是相同的人，需要保持唯一性
public static void main(String[] args){
    Map<Person,String> map=new HashMap<Person,String>();
    map.put(new Person("zhang3",18),"beijing");
    map.put(new Person("zhang4",19),"didu");
    map.put(new Person("zhang5",21),"modu");
    //map.put(new Person("zhang5",21),"將要替換掉modu");若已經儲存了(new Person("zhang5",21),"modu")；再put(new Person("zhang5",21),"將要替換掉modu")，由於已經儲存了(new Person("zhang5",21))再put時會替換原來的值變成新的值
//第一種keySet方式遍歷
Set<Person> set=map.keySet();
Iterator<Person> it=set.iterator();//得到Set集合的迭代器
while(it.hasNext()){
    Person key=it.next();//通過迭代器獲取鍵
    String value=map.get(key);//map根據鍵獲取對應的值
    System.out.println(key.toString()+":"+value);
    }
//第二種方式entrySet
Set<Map.Entry<Person,String>> entrySet=map.entrySet();
Iterator<Map.Entry<Person,String>> iter=entrySet.iterator();//得到Set集合的迭代器
while(iter.hasNext()){
    Map.Entry<Person,String> pa=iter.next();//通過迭代器獲取鍵
    Person key=pa.getKey();//獲取鍵
    String value=pa.getValue();
    System.out.println(key.toString()+":"+value);
}
}

四Map體系集合之TreeMap

TreeMap是可以排序的Map集合，TreeMap底層資料結構是二叉樹，執行緒不同步，可以用於給Map中的鍵Key排序，可以通過compareTo方法來排序，也可以通過傳入比較器構造Map集合來覆蓋掉comareTo方法來實現排序。

1例：把Person物件儲存到TreeMap，並按照姓名、年齡排序

class  Person implements Comparable<Person>{
    private String name;
    private int age;

    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    //預設的是先根據年齡排序的，年齡相同再按照姓名排序
    public int compareTo(Person s){
        int num=new Integer(this.age).compareTo(new Integer(s.age));
        if(num==0){
            return this.name.compareTo(s.name);
        }
        else{
            return num;
        }
    }
    //為了去除重複必須重新構造hashCOde
    public int hashCode()
    {
        return name.hasCode()+age*37;
    }

    //當雜湊值相同的時候才會執行
    public boolean equals(Object obj){
        if(!(obj instanceof Person)){
            throw new ClassCastException("型別不匹配");
        }
        Person p=(Person)obj;
        return this.name.equals(p.name) && this.age==p.age;
    }
    public String toString(){
        return "姓名："+name+"年齡："+age;
    }
}

如果不更改Person物件的原始碼，就是按照預設的排序規則（先按照年齡再根據姓名），好在TreeMap

class PersonNameComparator implements Comparator<Person>{
    public int compare(Person s,Person s2){
        int re=s.getName().compareTo(s2.getName());
        if(re==0){
            return new Integer(s.getAge()).compareTo(new Integer(s2.getAge()));
        }
        return re;
    }
}

測試類

public static void main(String[] args){
    TreeMap<Person,String> tm=new TreeMap<Person,String>(new PersonNameComparator());
    tm.put(new Person("azhang3",18),"beijing");
    tm.put(new Person("dzhang4",19),"didu");
    tm.put(new Person("bzhang5",21),"modu");

    Set<Map.Entry<Person,String>> entrySet=map.entrySet();
    Iterator<Map.Entry<Person,String>> iter=entrySet.iterator();//得到Set集合的迭代器
    while(iter.hasNext()){
        Map.Entry<Person,String> pa=iter.next();//通過迭代器獲取鍵
        Person key=pa.getKey();//獲取鍵
        String value=pa.getValue();
        System.out.println(key.toString()+":"+value);
    }
}

2 獲取指定字串中的字母次數，如“asdfsafddwewdwss”，列印結果a(1)d(4)……

public String charCount(String str){
    chars[] chs=str.toCharArray();
    TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();//錯誤的，泛型不允許使用基本型別必須使用引用型別TreeMap<char,int> tm=new TreeMap<char,int>();
    int count=0;
    for(int x=0;x<chs.length;x++){
        if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z')){
            continue;
        }
        Integer value=tm.get(chs[x]);
        if(value!=null){
            count=value;
        }
        count++;
        tm.put(chs[x],count);
        count=0;
    }
    StringBuilder sb=new StringBuilder();
    Set<Map.Entry<Character,Integer>> enteySet=tm.entrySet();
    Iterator<Map.Entry<Character,Integer>> it=enteySet.iterator();
    while(it.hasNext()){
        Map.Entry<Character,Integer> me=it.next();
        Character ch=me.getKey();
        Integer value=me.getValue();
        sb.append(ch+"("+value+")");
    }
    return sb.toString();
}