Map1.0

Map

Map接口可以用数学中的函数的思想来学习Map集合。Map接口中的每一个元素都是键(key)到值(value)的映射，每一个键(key)都只对应一个值(value)（键和值是一一对应的关系）。Map接口是一个种双列集合，每一个元素都包含一个键对象Key和一个值对象Value，键和值之间存在着映射。Map集合中不允许重复。
Map集合中的常用方法：

void put(Object key,Object value);          //将指定的值和键存入集合并进行指定的映射关系
Object get(Object key);                     //返回指定的键所对应的值；如果集合中不存在改键返回(即不存在对应的值)null
void clear();                               //移除所有元素
V remove(Object key);                       //根据对应的键删除对应的值和该键，返回被删除的值
int size();                                 //返回集合中键值对的个数
boolean containsKey(Object key);            //如果此映射包含指定键的映射关系，返回true
boolean containsValue(Object value);        //如果此映射包含指定值的映射关系，返回true
Set keySet();                               //返回一个由键组成的set集合
Collection<V> value();                      //返回一个由值组成的Collection集合
Set<Map.Entry<K,V>>entrySet();              //返回一个包含此映射关系的set集合

HashMap

HashMap是Map接口的一个实现类，HashMap中的方法大部分都是Map接口方法的实现。常用的就是把HashMap集合对象的引用赋值给Map接口变量，HashMap中是无序不重复的。
例子：

package text1;

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


public class Test19 {
    public static void main(String[] args){
        //创建集合对象
        Map<Integer,String> map=new HashMap<Integer, String>();
        //向集合中添加元素
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王二");
        //根据键获取值
        System.out.println("2对应的值是:"+map.get(2));
        System.out.println("3对应的值是:"+map.get(3));
        //判断集合中是否包含某个键
        System.out.println("集合中的键是否包含4："+map.containsKey(4));
        System.out.println("集合中的键是否包含2："+map.containsKey(2));
        //判断集合是否包含某个值
        System.out.println("集合中的值是否包含张三："+map.containsValue("张三"));
        System.out.println("集合中的值是否包含麻子："+map.containsValue("麻子"));
        //返回由键组成的Set集合并遍历
        Set<Integer> si=map.keySet();
        System.out.println("集合中所有的键为：");
        for(Integer i:si){
            System.out.println(i);
        }
        //返回由值组成的Collection集合并遍历
        Collection<String> cs=map.values();
        System.out.println("集合中所有的值为：");
        for(String s:cs){
            System.out.println(s);
        }
        //返回一个由映射关系为元素的Set集合
        Set<Map.Entry<Integer,String>> sm=map.entrySet();
        System.out.println("集合中的键值对为:");
        for(Map.Entry<Integer,String> m:sm){
            System.out.println(m);
        }
        //删除指定键对应的键值对
        System.out.println("删除的是："+map.remove(3));
        //清除所有的元素
        map.clear();
    }
}

结果展示如下：

LinkedHashMap

LinkedHashMap是HashMap的子类，HashMap中的元素是无序的，而LinkedHashMap是有序的（存入顺序和遍历顺序是一致的）。而且LinkedHashMap和LinkedList一样使用的都是双向链表维护内部元素的关系。
下面例子：

package text1;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class Test20 {
    public static void main(String[] args) {
        //创建一个LinkedHashMap集合对象并赋值Map接口变量
        Map<Integer,String> map=new LinkedHashMap<Integer, String>();
        //向集合中添加元素
        map.put(1,"张三");
        map.put(3,"王二");
        map.put(2,"李四");
        //遍历集合元素
        Set<Map.Entry<Integer,String>> sm=map.entrySet();
        for(Map.Entry<Integer,String> m:sm){
            System.out.println(m);
        }
    }
}

结果如下：

虽然这个和上一个HashMap中的例子遍历结果显示输入顺序和输出顺序是一样的，这是因为HashMap集合会根据键进行自动排序，所以说我们会看到他进行1、2、3的输出，如果你感兴趣可以自己写一下程序，多试几次。

TreeMap

HashMap集合存储的元素的键是无序的（输入顺序和输出顺序是不一致的，但是HashMap集合再存储元素时会根据键值对的键进行自动排序）和不可重复的，为了对集合中的元素的键进行排序，Map接口还有一个可以对元素的键进行排序的实现类——就是 TreeMap。
例子：

package text1;

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

public class Test21 {
    public static void main(String[] args) {
        //创建一个TreeMap对象，赋值给Map接口变量
        Map<Integer,String> map=new TreeMap<Integer,String>();
        //向集合中添加元素
        map.put(1,"张三");
        map.put(3,"王二");
        map.put(2,"李四");
        //获取该集合的映射关系并创建一个Set集合
        Set<Map.Entry<Integer,String>> sm=map.entrySet();
        //遍历
        for(Map.Entry<Integer,String> m:sm){
            System.out.println(m);
        }
    }
}

结果显示如下：

Treemap之所以可以对添加的元素的键进行排序，是因为它和TreeSet一样，TreeMap集合的排序也分为自然排序和自定义排序。下面使用一个自定义的类作为TreeSet的键并重写toString()方法和自定义排序方法：

package text1;

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

public class Test22 {
    static class Student{
        private String name;
        private int age;

        public Student() {}
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
        public String toString(){
            return "name="+name+",age="+age;
        }
    }

    public static void main(String[] args) {
        Map<Student,String> map=new TreeMap<Student,String>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num=s1.getAge()-s2.getAge();//先根据Student的age进行排序，再根据民资进行排序
                return num==0?s2.getName().compareTo(s1.getName()):num;
            }
        });
        //添加集合元素
        map.put(new Student("张三",15),"上海");
        map.put(new Student("李四",15),"广州");
        map.put(new Student("王二",14),"北京");
        //创建一个由该映射关系组成的Set集合
        Set<Map.Entry<Student,String>> sm=map.entrySet();
        //遍历Set集合
        for(Map.Entry<Student,String> m:sm){
            System.out.println(m);
        }
    }
}

结果显示如下：