Map的知识点梳理（不包含collections工具类）

一：基础公共方法（map不再是简单的加索引，可以直接命名key，通过key进行遍历）

1.常见的map子类

　　HashTable：底层是哈希表结构。不允许null键和null值，线程同步

　　HashMap：底层是哈希表结构，可以允许null键和null值，线程不同步

　　TreeMap：底层是二叉树结构，线程不同步，可以给map的键排序

2.map程序--公共的方法

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Test60 {

    public static void main(String[] args) {
        Map<Integer,String> hashMap=new HashMap<>();
        //增
        hashMap.put(1, "java1");
        hashMap.put(2, "java2");
        hashMap.put(3, "java3");
        //判断
        System.out.println(hashMap.containsKey(2));
        System.out.println(hashMap.containsValue("java2"));
        System.out.println(hashMap.isEmpty());
        //删除
        System.out.println(hashMap.remove(3));
        //获取1
        System.out.println(hashMap);
        System.out.println(hashMap.get(2));
        //获取2
        Collection<String> col=hashMap.values();//values方法返回的是Collection，这时候可以使用迭代器迭代出成员。
        Iterator it=col.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

}

3.运行结果

　　

二：map遍历的两个重要方法

1.keyset的使用

　　把map转换成Set类型，就是将所有的键存入到Set<K>中。

　　再使用get（K）来获得对应的value值。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Test61 {
    public static void main(String[] args) {
        Map<Integer,String> hashMap=new HashMap<>();
        hashMap.put(1, "java1");
        hashMap.put(2, "java2");
        hashMap.put(3, "java3");
        Set<Integer> keySet=hashMap.keySet();
        Iterator<Integer> it=keySet.iterator();
        while(it.hasNext()){
            Integer key=it.next();
            String value=hashMap.get(key);
            System.out.println(key+":"+value);
        }
    }
}

2.运行结果

　　

3.entrySet的使用

　　返回包含键值关系的Set视图，返回值放入Set中，类型是Map.Entry<K,V>。

　　得到映射关系后，可以选择的方法是getKey与getValue分别取出key与value。

public static void main(String[] args) {
        Map<Integer,String> hashMap=new HashMap<>();
        hashMap.put(1, "java1");
        hashMap.put(2, "java2");
        hashMap.put(3, "java3");
        Set<Map.Entry<Integer,String>> set=hashMap.entrySet();
        Iterator<Map.Entry<Integer, String>> itr=set.iterator();
        while(itr.hasNext()){
            Map.Entry<Integer, String> mapentry= itr.next();
            Integer key=mapentry.getKey();
            String value=mapentry.getValue();
            System.out.println(key+"::"+value);
        }
    }

4.运行结果

　　

三：map扩展

1.HashMap

　　保证学生对象的唯一性。

　　对学生对象的id进行排序。

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class Test63 {    
    public static void main(String[] args) {
        TreeMap<Student,String> tm=new TreeMap<>();
        tm.put(new Student(1,"zhangsan"),"beijing");
        tm.put(new Student(2,"lisi"),"shanghai");
        tm.put(new Student(4,"zhaoliu"),"hangzhou");
        tm.put(new Student(3,"wangwu"),"shenzhen");
        tm.put(new Student(2,"lisi"),"shanghai");
        Set<Map.Entry<Student,String>> set=tm.entrySet();
        Iterator<Map.Entry<Student,String>> itr=set.iterator();
        while(itr.hasNext()){
            Map.Entry<Student, String> me=itr.next();
            Student stu=me.getKey();
            String str=me.getValue();
            System.out.println(stu+"::"+str);
        }    
    }
}
class Student implements Comparable<Student>{
    private int id;
    private String name;
    Student(int id,String name){
        this.id=id;
        this.name=name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int compareTo(Student s){
        int num=new Integer(this.id).compareTo(new Integer(s.id));
        if(num==0){
            return name.compareTo(s.name);
        }
        return num;
    }
    public int hashCode(){
        return name.hashCode()+id*19;
    }
    public boolean equals(Object obj){
        if(!(obj instanceof Student)){
            return false;
        }
        Student s = (Student) obj;
        return this.name.equals(s.name)&&this.id==s.id;
    }
    @Override
    public String toString() {
        return "id=" + id + ", name=" + name;
    }
    
}

2.运行结果

　　可以进行排序，学生具备了自然排序的功能（comparable接口），并且对于重复的记录只会保存一条

　　

3.TreeMap

　　对学生对象的name进行排序，同时保持id具备自身的比较性。

　　student对象仍然是上面例子中的对象，不再改动。

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Test64 {
    public static void main(String[] args) {
        TreeMap<Student,String> tm=new TreeMap<>(new StunameComparator());
        tm.put(new Student(1,"zhangsan"),"beijing");
        tm.put(new Student(2,"lisi"),"shanghai");
        tm.put(new Student(4,"zhaoliu"),"hangzhou");
        tm.put(new Student(3,"wangwu"),"shenzhen");
        tm.put(new Student(2,"lisi"),"shanghai");
        Set<Map.Entry<Student,String>> set=tm.entrySet();
        Iterator<Map.Entry<Student,String>> itr=set.iterator();
        while(itr.hasNext()){
            Map.Entry<Student, String> me=itr.next();
            Student stu=me.getKey();
            String str=me.getValue();
            System.out.println(stu+"::"+str);
        }    
    }
}
class StunameComparator implements Comparator<Student>{

    @Override
    public int compare(Student s1, Student s2) {
        int num=s1.getName().compareTo(s2.getName());
        if(num==0){
            return new Integer(s1.getId()).compareTo(s2.getId());
        }
        return num;
    }
    
}

4.运行结果

　　

5.小练习（统计字符串中出现的字符次数）

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Test65 {
    public static void main(String[] args) {
        String s=charCount("aaabdd");
        System.out.println(s);
    }
    private static String charCount(String str) {
        char[] arr=str.toCharArray();
        TreeMap<Character,Integer> tm=new TreeMap<>();
        int count=0;
        for(int i=0;i<arr.length;i++){
            if(!(arr[i]>='a'&&arr[i]<='z'||arr[i]>='A'&&arr[i]<='Z'))
                continue;
            Integer value=tm.get(arr[i]);
            System.out.println("-----"+value);
            if(value!=null)
                count=value;
            count++;
            tm.put(arr[i], count);
            count=0;
        }
        StringBuffer sb=new StringBuffer();
        Set<Map.Entry<Character,Integer>> entry=tm.entrySet();
        Iterator<Map.Entry<Character, Integer>> itr=entry.iterator();
        while(itr.hasNext()){
            Map.Entry<Character, Integer> me=itr.next();
            Character ch=me.getKey();
            Integer value=me.getValue();
            sb.append(ch+"("+value+")");
        }
        return sb.toString();
    }
}

 6.运行结果