Java基础 集合Map

Map

Map集合:该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
和Set很像，Set底层就是使用了Map集合

1，添加
    V put(K key, V value) 
    返回：此哈希表中指定键的以前的值；如果不存在该值，则返回 null 

    void putAll(Map< ? extends K,? extends V> m) 

2，删除

     V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

    void clear()
3，判断
    boolean containsKey(Object key)如果此映射包含指定键的映射关系，则返回 true。
    boolean containsValue(Object value)如果此映射将一个或多个键映射到指定值，则返回 true。
    boolean isEmpty()
4，获取
    V get(Object key)返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
    Collection<V> values()返回此映射中包含的值的 Collection 视图。
    int size()  
     Set<K> keySet() 返回此映射中包含的键的 Set 视图。
     Set<Map.Entry<K,V>> entrySet() 
      返回此映射中包含的映射关系的 Set 视图。 

基本方法演示

import java.util.*;
class MapDemo
{
    public static void main(String[] args)
    {
        Map<String,String> map = new HashMap<String,String>();

        map.put("01","value1");
        map.put("02","value2");
        map.put("03","value3");
        map.put("01","value001");//覆盖老的值，返回原来的值
        map.put(null,"snull");

        Collection<String> coll=map.values();

        System.out.println("containsKey:"+map.containsKey("01"));
        System.out.println("get:"+map.get("01"));//返回value1
        System.out.println("null:"+map.get(null));//返回snull
        //System.out.println("remove:"+map.remove("01"));//返回value1
        System.out.println("remove:"+map.remove("0"));//返回null
        System.out.println("map:"+map);//

        System.out.println(coll);
    }
}

输出:

containsKey:true
get:value001
null:snull
remove:null
map:{null=snull, 01=value001, 02=value2, 03=value3}
[snull, value001, value2, value3]

---

Hashtable

底层是哈希表数据结构，不可以存入null键 null值
该集合线程同步。jdk1.0 效率低

HashMap

底层是哈希表数据结构，允许使用null键 null值
该集合线程不同步。jdk1.2 效率高

keySet()//获取所有键

import java.util.*;
class MapDemo1
{
    public static void main(String[] args)
    {
        Map<String,String> map = new HashMap<String,String>();

        map.put("01","value1");
        map.put("02","value2");
        map.put("03","value3");

        System.out.println("取出所有的键值对");
        Set<String> keys=map.keySet();
        for(Iterator<String> it=keys.iterator();it.hasNext();)
        {
            String k=it.next();
            String v=map.get(k);
            System.out.println(k+":"+v);
        }
        System.out.println("------------------");
    }   
}

输出:
取出所有的键值对
01:value1
02:value2
03:value3
——————

entrySet()//获取所有键值对

import java.util.*;

class MapDemo2
{
    public static void main(String[] args)
    {
        Map<String,String> map=new HashMap<String,String>();
        map.put("k1","v1");
        map.put("k2","v2");
        map.put("k3","v3");

        Set<Map.Entry<String,String>> entrySet = map.entrySet();

        Iterator<Map.Entry<String,String>> it = entrySet.iterator();

        while(it.hasNext())
        {
            Map.Entry<String,String> me=it.next();
            System.out.println("key:"+me.getKey()+" value:"+me.getValue());
        }
    }
}

输出:
key:k1 value:v1
key:k2 value:v2
key:k3 value:v3

TreeMap

底层是二叉树数据结构，可以用于给map集合中的键进行排序
线程不同步。

---

练习

使用 map 存储 学生,地址

学生有 名字，年龄 两个属性

并打印结果使用无序使用 HashMap

import java.util.*;

class MapTest
{
    public static void main(String[] args)
    {
        Map<Student,String> map=new HashMap<Student,String>();
        map.put(new Student("张三",18),"北京");
        map.put(new Student("李四",20),"北京");
        map.put(new Student("大明",25),"上海");
        map.put(new Student("大明",25),"武汉");

        Set<Map.Entry<Student,String>> mySet=map.entrySet();

        Iterator<Map.Entry<Student,String>> ite=mySet.iterator();
        System.out.println(new Student("张三",18).equals(new Student("张三",18)));
        while(ite.hasNext())
        {
            Map.Entry<Student,String> ent=ite.next();
            Student K=ent.getKey();
            System.out.println(K+" Value:"+ent.getValue());
        }
    }

}


class Student implements Comparable<Student>
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int compareTo(Student s)
    {
         int num=new Integer(this.age).compareTo(new Integer(s.age));
         if(num==0)
             return this.name.compareTo(s.name);
         return num;
    }
    public int hashCode()
    {
        return name.hashCode()+age*2;
    }

    public boolean equals(Object obj)
    {
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
        Student s=(Student)obj;
        if(name.equals(s.getName()) && age==s.getAge())
            return true;

        return false;
    }
    public String toString()
    {
        return name+":"+age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

输出:
true
大明:25 Value:武汉
张三:18 Value:北京
李四:20 Value:北京

练习2使用 TreeMap

同上题，使用学生姓名，年龄进行排序。
向TreeMap中传入一个比较器,Comparator
比较两个Student的name和age

import java.util.*;

class StuNameComparator implements Comparator<Student>
{
    public int compare(Student s1,Student s2)
    {
        int num=s1.getName().compareTo(s2.getName());
        if(num==0)
            return new Integer(s1.getAge()).compareTo(s2.getAge());
        return num;
    }
}
class MapTest2
{
    public static void main(String[] args)
    {
        Map<Student,String> map=new TreeMap<Student,String>(new StuNameComparator());
        map.put(new Student("aa1",25),"北京");
        map.put(new Student("aa2",20),"北京");
        map.put(new Student("bb1",23),"上海");
        map.put(new Student("bb2",28),"武汉");
        map.put(new Student("bb2",18),"武汉");

        Set<Map.Entry<Student,String>> mySet=map.entrySet();

        Iterator<Map.Entry<Student,String>> ite=mySet.iterator();
        System.out.println(new Student("张三",18).equals(new Student("张三",18)));
        while(ite.hasNext())
        {
            Map.Entry<Student,String> ent=ite.next();
            Student K=ent.getKey();
            System.out.println(K+" Value:"+ent.getValue());
        }
    }

}


class Student implements Comparable<Student>
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int compareTo(Student s)
    {
         int num=new Integer(this.age).compareTo(new Integer(s.age));
         if(num==0)
             return this.name.compareTo(s.name);
         return num;
    }
    public int hashCode()
    {
        return name.hashCode()+age*2;
    }

    public boolean equals(Object obj)
    {
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
        Student s=(Student)obj;
        if(name.equals(s.getName()) && age==s.getAge())
            return true;

        return false;
    }
    public String toString()
    {
        return name+":"+age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

输出:
true
aa1:25 Value:北京
aa2:20 Value:北京
bb2:18 Value:武汉
bb2:28 Value:武汉