黑马程序员<<Map>>

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------

1. Map

Map也是一个集合，只是是以键值对存储的，常见的子类有Hashtable,HashMap,TreeMap。

Hashtable：是1.0版本，底层的数据结构是哈希表，键和值和不能是null值，线程安全，和HashMap比较，效率低。

HashMap：是1.2版本的，底层也是哈希表数据结构，键和值可以为空(null),线程不安全，效率比较高。更确切的说，HashMap是Hashtable的升级版。

TreeMap：可以排序，底层是二叉树。

下面以HashMap为例，介绍一下Map集合。

2. HashMap

1. 添加元素

import java.util.HashMap;
import java.util.Map;
public class MapDemo {
   public static void main(String[] args) {
     /* 定义了一个Map集合，键和值的类型都是String */
     Map<String, String> map = new HashMap<String, String>();
     map.put("110", "张三");
     map.put("111", "李四");
     map.put("112", "王五");
     System.out.println("Map集合中的键和值：" + map);
     System.out.println("----------------");
     /* 利用put方法来添加元素，返回值是当前键以前对应的值，如果没有则返回null
      *当添加了相同的键，那么新的键和值会替换原来的键和值
      * */
     System.out.println(map.put("111", "赵六"));//这里返回的是李四，因为此集合中前面有111键对应的值
     System.out.println(map.put("113", "王刚"));//此时返回的是null，因为此集合中前面没有与113键对应的值
     System.out.println("Map集合中的键和值：" + map);
   }
}
结果：
Map集合中的键和值：{112=王五, 110=张三, 111=李四}
----------------
李四
null
Map集合中的键和值：{112=王五, 113=王刚, 110=张三, 111=赵六}

2.判断元素

import java.util.HashMap;
import java.util.Map;
 
public class MapDemo {
   public static void main(String[] args) {
     /* 定义了一个Map集合，键和值的类型都是String */
     Map<String, String> map = new HashMap<String, String>();
     map.put("110", "张三");
      map.put("111", "李四");
     map.put("112", "王五");
     System.out.println("Map集合中的键和值：" + map);
     /*
      * 利用booleancontainsKey(Object key)判断集合中是否有此键利用boolean
      * containsValue(Objectvalue)判断此集合中是否有此值
      */
     System.out.println("集合中是否包含110键：" + map.containsKey("110"));
     System.out.println("集合中是否包含000键：" + map.containsKey("000"));
     System.out.println("集合中是否包含   张三   值：" +map.containsValue("张三"));
     System.out.println("集合中是否包含     王梅    值：" +map.containsValue("王梅"));
   }
}
结果：
Map集合中的键和值：{112=王五, 110=张三, 111=李四}
集合中是否包含110键：true
集合中是否包含000键：false
集合中是否包含   张三   值：true
集合中是否包含     王梅    值：false

3.删除元素

import java.util.HashMap;
import java.util.Map;
 
public class MapDemo {
   public static void main(String[] args) {
     /* 定义了一个Map集合，键和值的类型都是String */
     Map<String, String> map = new HashMap<String, String>();
     map.put("110", "张三");
     map.put("111", "李四");
     map.put("112", "王五");
     map.put("113", "赵六");
     System.out.println("Map集合中的键和值：" + map);
     /*
      * 利用remove(Objectkey)通过键来删除元素，返回值是此键以前对应的值，如果不存在返回null 利用void
      * clear()清空集合中的元素
      */
     System.out.println("删除 110键对应的元素：" + map.remove("110"));// 这里返回是张三
     System.out.println("删除 120键对应的元素：" + map.remove("120"));// 这里返回null，因为此集合中没有120对应的值
     System.out.println("删除指定元素的集合：" + map);
     map.clear();// 清空集合
     System.out.println("清空集合后的集合：" + map);
   }
}
结果：
Map集合中的键和值：{112=王五, 113=赵六, 110=张三, 111=李四}
删除 110键对应的元素：张三
删除 120键对应的元素：null
删除 指定元素的集合：{112=王五, 113=赵六, 111=李四}
清空集合后的集合：{}

3. 获取元素

1.单个获取

 import java.util.HashMap;
import java.util.Map;
 
public class MapDemo {
   public static void main(String[] args) {
     /* 定义了一个Map集合，键和值的类型都是String */
     Map<String, String> map = new HashMap<String, String>();
     map.put("110", "张三");
     System.out.println("Map集合中的键和值：" + map);
     /*
      * 利用get(Objectkey)获取键对应的单个值，如果不存在，然会null
      */
     System.out.println("获取110对应的值：" + map.get("110"));// 这里返回是张三
     System.out.println("获取111对应的值：" + map.get("111"));// 这里返回是null
 
   }
}
结果：
Map集合中的键和值：{110=张三}
获取110对应的值：张三
获取111对应的值：null

2. 获取键的集合

package www.fuxi.jihe;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class MapDemo {
   public static void main(String[] args) {
     /* 定义了一个Map集合，键和值的类型都是String */
     Map<String, String> map = new HashMap<String, String>();
     map.put("110", "张三");
     map.put("111", "李四");
     map.put("112", "王五");
     System.out.println("Map集合中的键和值：" + map);
     /*
      * 利用Set<K>keySet()获取集合中键的集合返回值是Set集合
      * 我们可以通过Set集合中的迭代器读取出键，然后再通过get(key)获取元素
      */
     Set<String> set = map.keySet();// 获得键的集合
     Iterator<String> it = set.iterator();// 获得键集合的迭代器
     while (it.hasNext()) {
        String key = it.next();
        System.out.println(key + ":" + map.get(key));
     }
     /*
      * 利用Set<K>keySet()获取集合中键的集合返回值是Set集合然后把集合装换成数组，然后读取也可以
      */
     System.out.println("----------\n");
     Object[] keys = set.toArray();
     for (int i = 0; i < keys.length; i++) {
        System.out.println((String) keys[i] + "："
             + map.get((String) keys[i]));
     }
 
   }
}
 
结果：
Map集合中的键和值：{112=王五, 110=张三, 111=李四}
112:王五
110:张三
111:李四
----------
 
112：王五
110：张三
111：李四

3.获取值的集合

 packagewww.fuxi.jihe;
 
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class MapDemo {
      publicstatic void main(String[] args) {
           /* 定义了一个Map集合，键和值的类型都是String */
           Map<String,String> map = new HashMap<String, String>();
           map.put("110","张三");
           map.put("111","李四");
           map.put("112","王五");
           System.out.println("Map集合中的键和值：" + map);
           /**
            * 通过方法Collection<V>values()获得集合中的所有值
            */
           System.out.println("集合中的值：");
       Collection<String>values=map.values();
       Iteratorit=values.iterator();
      while(it.hasNext()){
           System.out.println(it.next());
       }
      }
}结果：
   Map集合中的键和值：{112=王五, 110=张三, 111=李四}
集合中的值：
王五
张三
李四

4. 通过映射关系

 import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class MapDemo {
   public static void main(String[] args) {
     /* 定义了一个Map集合，键和值的类型都是String */
     Map<String, String> map = new HashMap<String, String>();
     map.put("110", "张三");
     map.put("111", "李四");
     map.put("112", "王五");
     System.out.println("Map集合中的键和值：" + map);
     /*
      * 利用Set<Map.Entry<K,V>>entrySet()获取集合中的映射关系
      * 然后通过迭代器读取Set集合
      * 然后利用Map.Entry中的K getKey()获得键，V getValue()获取值
      */
      Set<Map.Entry<String,String>> set=map.entrySet();//获得映射的集合
      Iterator<Map.Entry<String,String>>  it=set.iterator();//获得迭代器
       while(it.hasNext()){
         Map.Entry<String, String> en=it.next();//获取集合中的元素
         String key=en.getKey();
         String value=en.getValue();
         System.out.println("键-值："+key+"-"+value);
       }
 
   }
}
 
结果：
Map集合中的键和值：{112=王五, 110=张三, 111=李四}
键-值：112-王五
键-值：110-张三
键-值：111-李四
 

Map.Entry是Map中的静态接口，此表示的把Map中的元素表示为映射关系

staticinterface

Map.Entry<K,V> 映射项（键-值对）。

4. HashMap和TreeMap的比较使用

HashMap比较的时候依赖于hashCode()和equals(Object ob)方法

TreeMap可以添加比较器或者是自然排序，对象实现接口comparable。

1. 利用HashMap

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class HashMapDemo {
  public static void main(String[] args) {
    /* 定义HashMap，里面存储的是Student和地址 */
    HashMap<Student, String> map = new HashMap<Student, String>();
    map.put(new Student("张三", 23), "北京");
    map.put(new Student("李四", 24), "上海");
    map.put(new Student("王五", 23), "南京");
    map.put(new Student("张三", 23), "广州");// 存了一个重复的值
 
    // 第一种读取方式
    Set<Student> set = map.keySet();
    Iterator<Student> it = set.iterator();
    while (it.hasNext()) {
      Student stu = it.next();
      String name = stu.getName();
      int age = stu.getAge();
      String address = map.get(stu);
      System.out.println(name + ":" + age + ":" + address);
    }
    System.out.println("---------");
    System.out.println("下面利用的是映射关系读取");
    Set<Map.Entry<Student, String>> ens = map.entrySet();
    Iterator<Map.Entry<Student, String>> its =ens.iterator();
    while (its.hasNext()) {
      Map.Entry<Student, String> me = its.next();
      Student stu = me.getKey();
      String address = me.getValue();
      System.out.println(stu.getName()+ ":" + stu.getAge() + ":"
           + address);
    }
  }
 
}
 
结果：
张三:23:广州
王五:23:南京
李四:24:上海
---------
下面利用的是映射关系读取
张三:23:广州
王五:23:南京
李四:24:上海

2. 利用TreeMap排序

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
 
public class TreeMapDemo {
  public static void main(String[] args) {
    /* 定义HashMap，里面存储的是Student和地址 */
    TreeMap<Student, String> map = new TreeMap<Student, String>();
    map.put(new Student("张三", 23), "北京");
    map.put(new Student("李四", 21), "上海");
    map.put(new Student("王五", 24), "南京");
    map.put(new Student("赵六", 26), "广州");
 
    Set<Student> set = map.keySet();
    Iterator<Student> it = set.iterator();
    while (it.hasNext()) {
      Student stu = it.next();
      String name = stu.getName();
      int age = stu.getAge();
      String address = map.get(stu);
      System.out.println(name + ":" + age + ":" + address);
    }
 
  }
 
}
结果：
李四:21:上海
张三:23:北京
王五:24:南京
赵六:26:广州
 

从结果可以看出，是按照年龄排序的，所以说TreeSet是具有排序的功能。

那么现在我们自定义比较器，是按照姓名排序。

import java.util.Comparator;
 
public class StuNameComparatorimplements Comparator<Student> {
/*按照姓名排序，如果姓名相同，那么按照年龄排序*/
  public int compare(Student o1, Student o2) {
    int num = o1.getName().compareTo(o2.getName());
    if (num == 0) {
      return o1.getAge() - o2.getAge();
    }
    return num;
  }
 
}
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
 
public class TreeMapDemo {
  public static void main(String[] args) {
    /* 定义HashMap，里面存储的是Student和地址 */
    TreeMap<Student, String> map = new TreeMap<Student, String>(newStuNameComparator());
    map.put(new Student("java03", 23), "北京");
    map.put(new Student("net02", 21), "上海");
    map.put(new Student("java01", 24), "南京");
    map.put(new Student("net03", 26), "广州");
 
    Set<Student> set = map.keySet();
    Iterator<Student> it = set.iterator();
    while (it.hasNext()) {
      Student stu = it.next();
      String name = stu.getName();
      int age = stu.getAge();
      String address = map.get(stu);
      System.out.println(name + ":" + age + ":" + address);
    }
 
  }
 
}
结果:
java01:24:南京
java03:23:北京
net02:21:上海
net03:26:广州

从结果可以看出，是按照姓名排序的，如果姓名相同，就按照年龄排序。

5. 练习

计算字符串中字符的个数，并且输出格式：a(1)b(3)c(4)….

思路：

1.把字符串转化成字符数组后，然后开始遍历数组

2.在遍历的时候，没读取一个字符，然后在集合中查看，如果存在则读取出来，然后数量加1，然后在存入里面如果没有，则添加里面，数量是1.

3.输出格式，读取集合然后拼接字符串，利用StringBuffer。

packagewww.fuxi.jihe;
 
importjava.util.HashMap;
importjava.util.Iterator;
importjava.util.Map;
importjava.util.Set;
 
public classMapDemo {
      public static void main(String[] args) {
           String str ="ahjdkdmkamkmixkxmcsnlasickdj";
           char[] cs = str.toCharArray();
           HashMap<Character, Integer> map= new HashMap<Character, Integer>();
           for (char c : cs) {
                 if (map.containsKey(c)) {
                      Integer count =map.get(c);// 取出此字符对应的数量
                      count++;// 数量++
                      map.put(c, count);// 然后重新添加里面，覆盖原来的
                 } else {
                      map.put(c, newInteger(1));// 开始数量为1
                 }
           }
 
           StringBuffer bu = new StringBuffer();
 
           Set<Character> set =map.keySet();
           Iterator<Character> it =set.iterator();
           while (it.hasNext()) {
                 Character c = it.next();
                 Integer count = map.get(c);
                 bu.append(c).append("(").append(count).append(")");
           }
           System.out.println(bu);
      }
}
结果：
d(3)s(2)c(2)a(3)n(1)l(1)m(4)j(2)k(5)h(1)x(2)i(2)

要是使用的是TreeMap，那么就会按照字符排序。

6. 模拟学校

模拟学校，然后读取学校中班级—学生信息

利用的是集合中嵌套集合

package www.fuxi.jihe;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
 
class CollegeStudent {
private Stringnum;
private Stringname;
 
CollegeStudent(Stringnum, String name) {
      super();
      this.num =num;
      this.name =name;
}
 
public StringgetNum() {
      return num;
}
 
public StringgetName() {
      returnname;
}
 
}
 
public class Demo {
public staticvoid main(String[] agrs) {
      /* 学校 */
      HashMap<String,List<CollegeStudent>> bdxy = new HashMap<String,List<CollegeStudent>>();
      List<CollegeStudent>ruanjian = new ArrayList<CollegeStudent>();// 软件班
      List<CollegeStudent>jiying = new ArrayList<CollegeStudent>();// 计应班
      /* 把班级添加到学校中 */
      bdxy.put("ruanjian",ruanjian);
      bdxy.put("jiying",jiying);
      /*向班级中添加学生*/
      ruanjian.add(newCollegeStudent("110","zhansgan") );
      ruanjian.add(newCollegeStudent("111","lisi") );
      ruanjian.add(newCollegeStudent("112","王五"));
      jiying.add(newCollegeStudent("210","wangang") );
      jiying.add(newCollegeStudent("211","wangemi") );
      jiying.add(newCollegeStudent("212","xiaoqiang") );
      /* 遍历学校中的班级，然后读取班级中的学生信息 */
 
      Set<String>set = bdxy.keySet();// 获取班级名称集合
      Iterator<String>it = set.iterator();
      while(it.hasNext()) {
            StringClassName = it.next();
            List<CollegeStudent>ClassInfo = bdxy.get(ClassName);// 获得班级
            System.out.println(ClassName);
            show(ClassInfo);
      }
}
 
/* 输出班级的学生 */
public staticvoid show(List<CollegeStudent> list) {
      Iterator<CollegeStudent>it = list.iterator();
      while(it.hasNext()) {
            CollegeStudentstu = it.next();
            System.out.println("  |-"+stu.getNum() + ":" +stu.getName());
      }
}
}
 
结果：
jiying
    |-210:wangang
    |-211:wangemi
    |-212:xiaoqiang
ruanjian
    |-110:zhansgan
    |-111:lisi
    |-112:王五

7.补充知识点

package www.fuxi.jihe;
 
import java.util.HashMap;
import java.util.Map;
 
public class Text {
  public static void main(String[] args) {
    Map<String,String> map=new HashMap<String,String>();
   
    map.put("110", "zhangsan");
    map.put("111", "lisi");
    map.put("112", "wangwu");
    System.out.println("集合："+map);
    /*boolean isEmpty()判断是否为空*/
    System.out.println(map.isEmpty());
    /*int size()判断集合中映射关系的个数*/
    System.out.println("大小："+map.size());
  }
 
}
 
结果：
集合：{112=wangwu, 110=zhangsan, 111=lisi}
false
大小：3
 

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------