对Map的一些总结

1：Map接口.

Collection体系中存储的是单个元素，单身汉，而Map中存储的是2个元素，存储的是成对的元素。

　　　　Map和Collection是没有联系的！！不要以为Map是Collection的一种或者Collection是Map的一种

1.1：特点

Map存储的是键值对，然而并不是所有键的数据类型都可以做为Map的键，只有引用数据类型才可以做键，基本数据类型是不能作为键的，键不能重复，值可以重复。

1.2：HashMap：底层是用哈希表来保证键的唯一性。方法跟Map接口中的方法是一样的。如果HashMap的键为自定义数据类型，那么这个类型也必须重写hashCode()和equals方法。来告诉HashMap如何去除重复元素。

 package com.java.domai;

 public class Student implements Comparable<Student>{
     private String Ename;
     private String Cname;
     private int age;
     private String sex;
     public Student() {
         super();
         // TODO Auto-generated constructor stub
     }
     public Student(String ename, String cname, int age, String sex) {
         super();
         Ename = ename;
         Cname = cname;
         this.age = age;
         this.sex = sex;
     }
     public Student(String cname, int age, String sex) {
         super();
         Cname = cname;
         this.age = age;
         this.sex = sex;
     }

     //...省略get和set方法

     @Override
     public String toString() {
         return "Student [Cname=" + Cname + ", age=" + age
                 + ", sex=" + sex + "]";
     }
     @Override
     public int compareTo(Student o) {
         // TODO Auto-generated method stub
         return age - o.age;
 //        return Cname.compareTo(o.Cname);
     }

 }

1.3：TreeMap：底层是用红黑树（二叉树）来保证键的唯一性，和对键进行排序。排序：如果返回值>0,则传入的数据放在右边

TreeMap的键的对象必须实现Comparable接口，重写compareTo方法。或者让TreeMap具有可比性，可以传一个比较器给集合。

 package com.java.treemap;

 import java.util.Comparator;
 import java.util.TreeMap;

 import com.java.domai.Student;

 /*
  * 需求：创建TreeMap集合，键为学生对象:学生：姓名，年龄，性别。，值为学生的地址，，放几个学生对象到TreeMap集合中
  * 再遍历集合。
  */
 public class TreeMapDemo3 {
     public static void main(String[] args) {
         TreeMap<Student, String> map = new TreeMap<Student, String>();
         map.put(new Student("aa", 20, "男"), "广州");
         map.put(new Student("aa", 20, "男"), "北京");
         map.put(new Student("cp", 22, "男"), "上海");
         map.put(new Student("cc", 22, "女"), "上海");
         map.put(new Student("dd", 23, "男"), "深圳");
         //System.out.println(map);
         // 以名字来进行排序

         TreeMap<Student, String> map2 = new TreeMap<Student, String>(new Comparator<Student>() {

             @Override
             public int compare(Student o1, Student o2) {
                 return o1.getCname().compareTo(o2.getCname());
             }
         });

         map2.put(new Student("aa", 20, "男"), "广州");
         map2.put(new Student("aa", 22, "女"), "广州");
         map2.put(new Student("bb", 25, "男"), "北京");
         map2.put(new Student("cp", 22, "男"), "上海");
         map2.put(new Student("cc", 22, "女"), "上海");
         map2.put(new Student("dd", 23, "男"), "深圳");
         System.out.println(map2);
     }

 }

1.4：HashTable：底层都是哈希表来保证键的唯一性。

跟HashMap区别

1：HashMap的键和值可以为null,而HashTable的键和值不能为null.

2：HashMap不是同步的，而HashTable是同步的。所以建议用HashMap.

1.5：Properties：键和值都是String。主要用于配置文件

　　　1.6：Map的遍历可以通过迭代器遍历：

　　　　　　

Map<String, String> map = new HashMap<String, String>();
        map.put("2012254101", "zjw");
        map.put("2012254102", "jjl");
        map.put("2012254103", "ywc");
        map.put("2012254104", "tj");

        Set<String> set = map.keySet();//获取键的Set集合，set和Map的键一样是不能重复的
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String key = it.next();
            String name = map.get(key);
            System.out.println(key+" : "+name);
        }

2.个人掌握了解Map和Collection混合用法的例子

 package com.java.map;
 好开心
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import com.java.domai.Student;//上面的Student类
 public class CopyOfHashMapDemo1 {
     public static void main(String[] args) {
         /*
          * 键就是对象的属性。值就是对象的属性值
          * 一个对象用一个Map类表示
          * 然后将这个Map装进一个集合里面
          */
         /*
         *这个List中泛型的数据类型是一个Map类型，做着做着发现后面不用list
         *而泛型Map的键第是班级Map<String, String>,值是学生列表List<Student>
         */

         List<Map<Map<String,String>, List<Student>>> schoolList = new ArrayList<Map<Map<String,String>, List<Student>>>();

         //用这个Map保存班级信息，key=class；value=班级
         Map<String, String> classMap1 = new HashMap<String, String>();
         classMap1.put("class", "Java");
         Map<String, String> classMap2 = new HashMap<String, String>();
         classMap2.put("class", "IOS");

         //创建两个学生集合吧
         List<Student> list1 = new ArrayList<Student>();
         list1.add(new Student("zjx", 34, "nan"));
         list1.add(new Student("zjx1", 32, "nan"));
         list1.add(new Student("zjx2", 12, "nan"));
         //创建两个学生集合吧
         List<Student> list2 = new ArrayList<Student>();
         list2.add(new Student("dell", 34, "nan"));
         list2.add(new Student("dell1", 32, "nan"));
         list2.add(new Student("dell2", 12, "nan"));

         //将班级map和学生list放到一个集合里，键是map,值是list。这个看起来很搞怪
         Map<Map<String, String>, List<Student>> map = new HashMap<Map<String,String>, List<Student>>();
         map.put(classMap1, list1);
         map.put(classMap2, list2);

         //开始获取key了
         //keyset:中文就是键的set了，用来保存key的一个set结合。
         //由于key在Map中是唯一的、不重复的，而Set保存的是不重复的元素，那就配合刚好
         //key的类型是Map<String, String>,所以Set的泛型类型也要这样
         Set<Map<String, String>> set = map.keySet();
         //可以直接打印看看
         //System.out.println(set);
         //要开始用迭代器了,迭代的泛型类型和set的一样
         Iterator<Map<String, String>> it = set.iterator();
         //遍历
         while(it.hasNext()){//如果有下个 话。。。
             //获取了Map类型的键了
             Map<String, String> key = it.next();
             //key既然是个Map，那么它里面就还有键值对咯,没错，就是班级的键值对
             String key2 = key.get("class");
             System.out.println(key2);
             //通过键来获取值吧，值是list类型的,是从最大的那个Map获取，就是List所在的那个Map
             List<Student> stuList = map.get(key);
             //得到List了可以遍历list，遍历的方式自己喜欢咯
             //先迭代试试
             Iterator<Student> it2 = stuList.iterator();
             while(it2.hasNext()){
                 Student stu = it2.next();
                 System.out.println("\t"+stu);
             }
             System.out.println("+++++++++++++");
             //也可以普通for循环遍历啊
             /*for(int i=0; i<stuList.size(); i++){
                 Student stu = stuList.get(i);
                 System.out.println("\t"+stu);
             }*/
             System.out.println("+++++++++++++");
             //还可以增强for循环
             /*for (Student student : stuList) {
                 System.out.println("\t"+student);
             }*/
             //System.out.println(key+" : "+stuList);
         }
         /*
          * ok 了，终于大功告成，虽然过程很绕，
          * 但是我基本上明白了Map 的添加数据，添加不同类型的数据作为键和值
          * 明白了怎样去使用迭代器去Map中的值，
          * 知道了迭代器中的泛型类型是和使用迭代方法的集合的泛型类型是一样的
          * 了解了几种循环遍历的方式，以及处理了繁杂的循环和取值
          * 我觉得我之前不理解的就是用Map作为键去取值，其实和普通的取值方式一样的了，就是个类型不同
          * Map<String, String>:键中有键，
          *
          *
          */

     }

 }