黑马程序员JAVA基础Java 集合之Map 接口

　　Map 用于保存具有映射关系的数据，因此Map 集合里保存者两组值，一组值用于保存Map 里的Key ，另一组值用于保存Map 里的Value ，其中key 和 value 都是可以是任何引用类型的数据。

　　注意：Map 的key 不允许重复，且通过指定的key，总能找到唯一的、确定的value。即key 和 value 之间存在单向一对一关系。

　　Map 接口的经常用到的实现类：HashMap、Hashtable和TreeMap。

一.Map 集合中的共性方法

　　1、添加：

　　> V put(K key, V value) : 添加一个key-value 对，如果当前Map中已有一个与该key 相等的key-value 对，则新的key-value 对会覆盖原来的，并返回原来的value。

　　> void putAll(Map<? extends K,? extends V> m)  从指定映射中将所有映射关系复制到此映射中。

　　2、删除：

　　> void clear() : 从此映射中移除所有映射关系 。

　　> V remove(Object key)  如果存在一个键的映射关系，则将其从此映射中移除 , 并返回 value 。

　　3、判断：

　　> boolean containsKey(Object key) :如果Map 中包含指定key ，则返回 true。

　　> boolean containsValue(Object value) : 如果Map 中包含一个或多个value ， 则返回true。

　　> boolean isEmpty() : 如果Map 为空，则返回true 。

　　4、获取：

　　> V get(Object key) 返回key 对应的value , 如果没有则返回null 。

　　> int size() 返回Map 中 key-value 对的个数。

　　> Collection values() : 返回该Map 里所有value 组成的Collection 。 

public class MapDemo {
    public static void main(String[] args)
    {
//        定义个 HashMap 集合， key 和 value的类型都为String。
        Map<String, String> map = new HashMap<String, String>() ; 
//        添加元素
        map.put("诛仙", "萧鼎") ;
        map.put("笑傲江湖", "金庸") ; 
        map.put("神雕侠侣", "金庸") ; 
        map.put("陆小凤传奇", "古龙") ; 
        System.out.println(map); 
        System.out.println(map.put("笑傲江湖", "金——庸"));
        System.out.println(map);
//        删除元素
        System.out.println(map.remove("笑傲江湖") );
        System.out.println(map);
//        获取元素
        System.out.println(map.get("诛仙")); 
//        获取元素个数
        System.out.println(map.size());
//        判断
        System.out.println(map.containsKey("诛仙"));
    }
}

 　　

二.HashMap 和 Hashtable 实现类：

　　HashMap 和 Hashtable 它们之间的关系完全类似于 ArrayList 和 Vector 的关系。它们两个底层都是哈希表数据结构，两者的区别：

　　1、Hashtable 不可以存入null 键和null 值；但是HashMap 可以存入null 键和null 值。

　　2、hashtable 是线程安全Map 实现；但HashMap 是线程不安全的实现类。所以HashMap 性能比较高点。

public class HashMapDemo {
    public static void main(String[] args)
    {
        Map<String,String> hash  = new HashMap<String, String>() ;
        
//        给HashMap 集合存入null键或者null值
        hash.put("111", null) ; 
        hash.put(null, "1112") ;
//        取出的结果为 1112
        System.out.println(hash.get(null));
        Map<String,String> table = new Hashtable<String, String>() ; 
//        下面的代码会出现运行异常：NullPointerException
        table.put("111", null) ; 
        table.put(null, "1112") ;
        System.out.println(table.get(null));
    }
}

　　类似HashSet ， HashMap 和 Hashtable 也不能保证其中的key-value 对的顺序。它们判断两个key的标准也是：

　　1、先判断两个key 的hashCode 值是不是相等，

　　2、如果相等则再调用equals方法的返回值来进行判断。返回true 表示两个key值一样；返回false 表示不一样。 

class Writer
{
    private String name ; 
    public Writer(String name)
    {
        this.name = name ; 
    }
//    get方法
    public String getName()
    {
        return name ;
    }
//    重写hashCode方法
    public int hashCode()
    {
        System.out.println(this.name+"---------hashCode--------");
        return this.name.hashCode() ; 
    }
//    重写equals方法
    public boolean equals(Object o)
    {
        if (!(o instanceof Writer))
            throw new  RuntimeException() ;   
        Writer w = (Writer) o ; 
        System.out.println(name+"---------equals--------"+w.name);
        return this.name.equals(w.getName()) ; 
    }
}
public class MapDemo1 {
    public static void main(String[] args)
    {
//        定义个 HashMap 集合， key 的存储的数据类型为Writer， value的类型为String。
        Map<Writer,String> writerMap = new HashMap<Writer,String>() ; 
        
//        添加元素：
        writerMap.put(new Writer("金庸"), "笑傲江湖") ;
        writerMap.put(new Writer("萧鼎"), "诛仙") ;
        writerMap.put(new Writer("金庸"), "笑傲江湖") ;
        
        System.out.println(writerMap);
    }
}

　　

　　　　

三.TreeMap 实现类

　　TreeMap 实现的的底层是二叉树的数据结构。线程是不同步的，其特点是：TreeMap 会对集合中所有 key 进行排序；也有两种排序方式：

　　1、自然排序： TreeMap 的所有key 必须实现Comparable 接口，而且所有key 必须是同一类对象。

　　2、制定排序： 编写比较器。在创建集合容器时将比较器传入至集合构造器。 

//创建Books类并且 实现Comparable 接口
//如果Books的名字和编号都相同则表示同一本书
class Books implements Comparable<Books>
{
    private String name ; 
    private String id ;
    public Books(String name , String id )
    {
        this.name = name ; 
        this.id = id ; 
    }
//    get方法
    public String getName()
    {
        return name ;
    }
    public String getId()
    {
        return id ;
    }
    
//    覆盖compareTo 方法
    public int compareTo(Books b)
    { 
        int num = this.id.compareTo(b.getId()) ;
        if (num == 0)
        {
            return this.name.compareTo(b.getName()) ;
        }
        return num ;
    }
//    重写hashCode 方法
    public int hashCode()
    {
        return this.name.hashCode()+ this.id.hashCode() ;
    }
//    重写equals 方法
    public boolean equals(Object o)
    {
        if (!(o instanceof Books))
            throw new RuntimeException() ;
        Books b = (Books) o ;
        return this.name.equals(b.getName())&& this.id.equals(b.getId()) ;
    }
}
public class TreeMapDemo {
    public static void main(String[] args)
    {
        Map<Books,String> bookMap = new TreeMap<Books, String> () ;
        
        bookMap.put(new Books("笑傲江湖","000001"), "金庸") ;
        bookMap.put(new Books("笑傲江湖","000002"), "金庸") ;
        bookMap.put(new Books("笑傲江湖","000004"), "金庸") ;
        bookMap.put(new Books("笑傲江湖","000003"), "金庸") ;
        bookMap.put(new Books("神雕侠侣","000001"), "金庸") ;
        
//        取出方式：entry()  
        Set<Entry<Books, String>> bookEntry = bookMap.entrySet() ;
        Iterator<Map.Entry<Books, String>> itEntry = bookEntry.iterator() ;
        while(itEntry.hasNext())
        {
            Map.Entry<Books, String> entry = itEntry.next() ; 
            System.out.println("name:" + entry.getKey().getName() +
                    "  id:" + entry.getKey().getId() +
                    "  作者: " + entry.getValue());
        } 
    }
}

　　

四.Map 集合的两种取出方式：

　　因为 Map集合中没有Iterator 迭代器，所以如果想将Map 集合中的元素遍历以便就要能用到下面两个方法：

　　1、Set<Map.Entry<K,V>> entrySet() ：返回此映射中包含的映射关系的 Set 视图。映射关系为 Map.Entry<K,V>类型 ;

　　2、Set<K> keySet()：将Map 中所有的键存入到Set集合中 ；

　　原理是：将Map 集合中的元素取出保存到Set 集合中，再根据Set 集合中的Iterator 迭代器取出。

　　

　　4.1 、 entrySet() 

　　Map.Entry<K,V> 为一个接口（Map 接口中的内部类），其用法和 Iterator 接口类似。该接口包含如下方法

　　> boolean equals(Object o) : 比较指定对象与此项的相等性。 

　　> K getKey() :  返回与此项对应的键。 

　　> V getValue() : 返回与此项对应的值。  

　　> int hashCode() : 返回此映射项的哈希码值。

　　> V setValue(V value) : 用指定的值替换与此项对应的值 。 

　　步骤如下： 

　　1、先获取Map 集合中的key-value 对的关系Set<Map.Entry<K,V>> 集合。 

　　2、获取 Set  集合的迭代器。 

　　3、遍历取出。 

class Writer
{
    private String name ; 
    public Writer(String name)
    {
        this.name = name ; 
    }
//    get方法
    public String getName()
    {
        return name ;
    }
//    重写hashCode方法
    public int hashCode()
    { 
        return this.name.hashCode() ; 
    }
//    重写equals方法
    public boolean equals(Object o)
    {
        if (!(o instanceof Writer))
            throw new  RuntimeException() ;   
        Writer w = (Writer) o ;  
        return this.name.equals(w.getName()) ; 
    }
}
public class MapDemo1 {
    public static void main(String[] args)
    {
//        定义个 HashMap 集合， key 的存储的数据类型为Writer， value的类型为String。
        Map<Writer,String> writerMap = new HashMap<Writer,String>() ; 
        
//        添加元素：
        writerMap.put(new Writer("金庸"), "笑傲江湖") ;
        writerMap.put(new Writer("萧鼎"), "诛仙") ;
        writerMap.put(new Writer("古龙"), "流星蝴蝶剑") ;
        
//        System.out.println(writerMap);
//        将Map 元素取出存入Set 集合，指定该Set集合只能存入MapEntry<>数据类型。
        Set<Map.Entry<Writer, String>> setMap = writerMap.entrySet() ;
//        建立迭代器
        Iterator<Map.Entry<Writer,String>> it = setMap.iterator() ;
        while(it.hasNext())
        {
//            取出key-value 对 
            Map.Entry<Writer, String> entry = it.next() ; 
            System.out.println("key:"+ entry.getKey().getName()+
                    "value:"+ entry.getValue()); 
        }
    }
}

　　4.2 keySet() :  

　　步骤：

　　1、先获取Map集合的所有键的Set集合。

　　2、获取Set集合的迭代器。

　　3、遍历。通过Mao集合get方法获取其对应的值。

class Writer
{
    private String name ; 
    public Writer(String name)
    {
        this.name = name ; 
    }
//    get方法
    public String getName()
    {
        return name ;
    }
//    重写hashCode方法
    public int hashCode()
    { 
        return this.name.hashCode() ; 
    }
//    重写equals方法
    public boolean equals(Object o)
    {
        if (!(o instanceof Writer))
            throw new  RuntimeException() ;   
        Writer w = (Writer) o ;  
        return this.name.equals(w.getName()) ; 
    }
}
public class MapDemo1 {
    public static void main(String[] args)
    {
//        定义个 HashMap 集合， key 的存储的数据类型为Writer， value的类型为String。
        Map<Writer,String> writerMap = new HashMap<Writer,String>() ; 
        
//        添加元素：
        writerMap.put(new Writer("金庸"), "笑傲江湖") ;
        writerMap.put(new Writer("萧鼎"), "诛仙") ;
        writerMap.put(new Writer("古龙"), "流星蝴蝶剑") ;
//        取出key ,存入Set 集合
        Set<Writer> setMap = writerMap.keySet() ; 
//        获取Set集合迭代器
        Iterator<Writer> it = setMap.iterator() ; 
        while(it.hasNext())
        {
            Writer w = it.next() ;
            System.out.println("key:"+w.getName() +
                    "value:" + writerMap.get(w));
        }

    }
}

五.Map 集合练习：

　　1、要求： 

　　每个学生都有一个归属地。

　　学生Student , 地址 String

　　学生的属性：姓名、年龄 

　　注意：姓名和年龄相同的视为同一个学生。  

class Student  
{
    private String name ; 
    private int age ; 
    public Student(String name , int age)
    {
        this.name = name ; 
        this.age = age ; 
    }
//    get方法：
    public String getName()
    {
        return name ;
    }
    public int getAge()
    {
        return age ;
    }
//    instanceof 判断函数：
    private Student myIstanceof(Object o)
    {
        if (!(o instanceof Student))
            throw new RuntimeException() ;
        return (Student) o ; 
    }
//    重写equals 方法
    public boolean equals(Object o)
    { 
        Student stu =  myIstanceof(o);
        return this.name.equals(stu.getName()) && this.age == stu.getAge() ;
    }
//    重写hashCode方法
    public int hashCode()
    {
         return name.hashCode()+age*39 ;
    } 
}
public class Demo {
    public static void main(String[] args)
    {
//        创建Map 类：
        Map<Student,String> stuMap = new HashMap<Student, String>() ; 
        
        stuMap.put(new Student("lisi002" , 11), "北京" ) ;
        stuMap.put(new Student("lisi001" , 14), "上海" ) ;
        stuMap.put(new Student("lisi005" , 10), "天津" ) ;
        stuMap.put(new Student("lisi005" , 19), "天津" ) ;
        stuMap.put(new Student("lisi001" , 19), "长沙" ) ;

        stuMap.put(new Student("lisi001" , 14), "北京" ) ; 
        
//        第一种取出方式：keySet() 
        Set<Student> stuSet = stuMap.keySet() ; 
        Iterator<Student> it = stuSet.iterator() ;  
        while(it.hasNext())
        {
            Student stu = it.next() ;
            System.out.println("name:"+stu.getName()
                    +"  age:"+stu.getAge() + "  地址：" + stuMap.get(stu));
        } 
        System.out.println("------我是分割线------");
//        第二种取出方式：entry()  
        Set<Map.Entry<Student, String>> stuEntry = stuMap.entrySet() ;
        Iterator<Map.Entry<Student, String>> itEntry = stuEntry.iterator() ;
        while(itEntry.hasNext())
        {
            Map.Entry<Student, String> entry = itEntry.next() ; 
            System.out.println("name:" + entry.getKey().getName() +
                    "  age:" + entry.getKey().getAge() +
                    "  地址: " + entry.getValue());
        }
    }  
}

　　

 　　2、字母出现的次数： 

　　输入一段字符串，获取该字符串中的字母出现的次数。

　　希望打印结果：

　　字母1(次数)字母2(次数)....

　　通过结果发现，每一个字母都有对应的次数，说明字母和次数间有对应关系。

public class TreeMapTest {
    public static void main(String[] args)
    {
        Scanner scan = new Scanner(System.in) ;
        String str = scan.nextLine() ;
        Map<Character,Integer> CNTree  = new TreeMap<Character, Integer>() ;
//        存入Map集合。
        char[] chs = str.toCharArray() ;
        for (int i = 0 ; i < chs.length ; i ++)
        {
            Integer values = CNTree.get(chs[i])  ;
            
            if (values == null )
                CNTree.put(chs[i], 1) ; 
            else 
                CNTree.put(chs[i], values+1) ; 
        }
        
//        遍历Map集合
        Set<Character> charSet = CNTree.keySet() ; 
        Iterator<Character> it = charSet.iterator() ; 
        while(it.hasNext())
        {
            Character character = it.next() ;
            System.out.println(character.charValue() +"   "+ CNTree.get(character));
        }
    } 
} 

　　思路：

　　1、将字符串转换成字符数组（因为要对每一个字母进行操作）。

　　2、定义一个map集合，使用TreeMap 集合。

　　3、遍历字符数组：

　　　　a、将每一个字母作为键去查Map集合。

　　　　b、如果返回null，将该字母和1存入Map集合中。

　　　　c、如果返回不是null，则自增后，存入Map集合中。

　　4、将Map集合中的数据打印。