Java上路14-Map集合

       将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

一. 代码示例：

import java.util.*;
 
/*
该集合存储键-值对，键具有唯一性。
 
增
       put(K key, V value)
       putAll(Map<?extends K, ? extends V> m)
 
删
       clear()
       remove(Object key)
 
查
       get(Object key)
       size()
       values()
 
       entrySet()
       keySet()
 
判断
       containsValue(Objectvalue)
       containsKey(Objectkey)
       isEmpty()
 
Map子类
       Hashtable：底层为哈希表数据结构，不可以存入null作为键值的情况，用作键的对象必须实现hashCode和equals方法。该集合线程同步。
       HashMap：哈希表结构，允许使用null键值，不同步。
       TreeMap：二叉树结构，可用于给Map集合中的键排序，线程不同步。
 
Map集合取出方式
       keySet：将map中索引的键存入到Set集合。然后使用Set的迭代器取出所有键，再根据get方法获取每个键
       entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry
*/
 
class MapDemo
{
       public static void main(String[] args)
       {
              Map<String,String> map=new HashMap<String, String>();
 
              //添加，如果键相同，会覆盖并返回原值-值
              map.put("01","Zhang San");
              map.put("02","Li Si");
              map.put("02","赵六");
              map.put("03","Wang Wu");
              map.put("04",null);
 
              //删除
              map.remove("");
 
              //查询
              map.get("");
 
              //判断是否有此键
              map.containsKey("02");
 
              //全取
              Collection<String> coll=map.values();
 
              //获取map集合的所有键的Set集合
              Set<String> keySet=map.keySet();
              //获取迭代器
              Iterator<String> it=keySet.iterator();
              while(it.hasNext())
              {
                     String key=it.next();
                     String value=map.get(key);
                     System.out.println("key:"+key+",value:"+value);
              }
 
              //将map集合中的映射关系取出，存入Set集合
              Set<Map.Entry<String,String>> entrySet=map.entrySet();
              for(Iterator<Map.Entry<String,String>> im=entrySet.iterator();im.hasNext();)
              {
                     Map.Entry<String,String> me=im.next();
                     String key=me.getKey();
                     String value=me.getValue();
                     System.out.println(key+"---"+value);
              }
       }
}   

二. 例子：

/*
学生：姓名、年龄，地址。
姓名和年龄相同的视为同一人。
*/
 
import java.util.*;
 
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)
       {
              System.out.println("自然排序...");
              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()
       {
              System.out.println("计算哈希值...");
              return name.hashCode()+age*19;
       }
 
       //比较姓名和年龄，重复的覆盖原有的
       public boolean equals(Object obj)
       {
              System.out.println("equals排序...");
              if(!(obj instanceof Student))
              {
                     throw new ClassCastException("类型不匹配");
              }
              Student s=(Student)obj;
              return this.name.equals(s.name) && this.age==s.age;
       }
 
       public String getName()
       {
              return name;
       }
 
       public int getAge()
       {
              return age;
       }
 
       public String toString()
       {
              return name+"___"+age;
       }
}
 
class MapTest
{
       public static void main(String[] args)
       {
              //学生（姓名，年龄），地址
              HashMap<Student,String> hm=new HashMap<Student, String>();
              hm.put(new Student("周鑫",21),"高庄");
              hm.put(new Student("周红",25),"高庄");
              hm.put(new Student("崔强",24),"南埠东");
              hm.put(new Student("李凯",23),"付家庄");
              hm.put(new Student("赵伟",26),"北麻村");
 
              //第一种取出keySet
              Set<Student> keySet=hm.keySet();
              Iterator<Student> it=keySet.iterator();
              while(it.hasNext())
              {
                     Student s=it.next();
                     String addr=hm.get(s);
                     System.out.println(s.toString()+"---"+addr);
              }
 
              System.out.println();
 
              //第二种：entrySet
              Set<Map.Entry<Student,String>> entrySet=hm.entrySet();
              Iterator<Map.Entry<Student,String>> ime=entrySet.iterator();
              while(ime.hasNext())
              {
                     Map.Entry<Student,String> me=ime.next();
                     Student s=me.getKey();
                     String addr=me.getValue();
                     System.out.println(s.toString()+"..."+addr);
              }
       }
}   

三. 例子：

/*
学生：姓名、年龄，地址。
姓名和年龄相同的视为同一人。
*/
 
import java.util.*;
 
class Student implements Comparable<Student>
{
       private String name;
       private int age;
       Student(String name, int age)
       {
              this.name=name;
              this.age=age;
       }
       public String getName(){
              return name;
       }
       public int getAge(){
              return age;
       }
       public String toString(){
              return name+"___"+age;
       }
}
 
//比较器
class StuNameComp 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(new Integer(s2.getAge()));
              }
              return num;
       }
}
 
class MapTest
{
       public static void main(String[] args)
       {
              //学生（姓名，年龄），地址
              TreeMap<Student,String> ts=new TreeMap<Student, String>(new StuNameComp());
/*
              ts.put(new Student("周鑫",21),"高庄");
              ts.put(new Student("赵伟",26),"北麻村");
              ts.put(new Student("崔强",24),"南埠东");
              ts.put(new Student("李凯",23),"付家庄");
              ts.put(new Student("周红",25),"高庄");
              ts.put(new Student("周红",22),"高庄");
*/
              ts.put(new Student("Zhou  Xin",21),"高庄");
              ts.put(new Student("Zhao  Wei",26),"北麻村");
              ts.put(new Student("Cui Qiang",24),"南埠东");
              ts.put(new Student("Li    Kai",23),"付家庄");
              ts.put(new Student("Zhou Hong",25),"高庄");
              ts.put(new Student("Zhou Hong",22),"高庄");
              System.out.println();
 
              Set<Map.Entry<Student,String>> entrySet=ts.entrySet();
              Iterator<Map.Entry<Student,String>> ime=entrySet.iterator();
              while(ime.hasNext())
              {
                     Map.Entry<Student,String> me=ime.next();
                     Student s=me.getKey();
                     String addr=me.getValue();
                     System.out.println(s.toString()+"..."+addr);
              }
       }
}   

 

四. 排序示例：

importjava.util.*;
 
class MapTest
{
       public static void main(String[] args)
       {
              String s= charCount("lkkgjhlljgjhgf");
              System.out.println(s);
       }
 
       public static String charCount(String str)
       {
              char chars[]=str.toCharArray();
              TreeMap<Character, Integer> tm=new TreeMap<Character, Integer>();
 
              int count=0;
              for (int x=0; x<chars.length;x++)
              {
                     Integer value=tm.get(chars[x]);
                     if (value!=null)
                     {
                            count=value;
                     }
                     count++;
                     tm.put(chars[x],count);
 
                     count=0;
              }
 
              StringBuilder sb=new StringBuilder();
 
              Set<Map.Entry<Character,Integer>> entry=tm.entrySet();
              Iterator<Map.Entry<Character,Integer>> it=entry.iterator();
 
              while (it.hasNext())
              {
                     Map.Entry<Character,Integer> me=it.next();
                     Character ch=me.getKey();
                     Integer value=me.getValue();
                     sb.append(ch+"("+value+")");
              }
 
              return sb.toString();
       }
}    

五. 嵌套：

import java.util.*;
 
class MapTest
{
       public static void main(String[] args)
       {
              HashMap<String,HashMap<String, String>> school=new HashMap<String,HashMap<String, String>>();
              HashMap<String, String> grade1=new HashMap<String, String>();
              HashMap<String, String> grade2=new HashMap<String, String>();
 
              school.put("一班", grade1);
              school.put("二班", grade2);
 
              grade1.put("0101","小明");
              grade1.put("0102","小红");
              grade1.put("0103","小强");
              grade1.put("0104","小新");
 
              grade2.put("0201","明明");
              grade2.put("0202","强强");
              grade2.put("0203","红花");
              grade2.put("0204","新仔");
 
              for (Iterator<String> it=school.keySet().iterator(); it.hasNext(); )
              {
                     String gradeName=it.next();
                     HashMap<String,String> grade=school.get(gradeName);
                     System.out.println(gradeName);
                     getStudent(grade);
              }
       }
 
       public static void getStudent(HashMap<String,String> grade)
       {
              for (Iterator<String> it=grade.keySet().iterator(); it.hasNext(); )
              {
                     String id=it.next();
                     String name=grade.get(id);
                     System.out.println(id+"---"+name);
              }
       }
}