Java基础之集合框架(三)--Map、HashMap、TreeMap

最新推荐文章于 2023-05-25 16:23:12 发布

自动改名

最新推荐文章于 2023-05-25 16:23:12 发布

阅读量719

点赞数

分类专栏： java基础

java基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

[java]view plaincopy 
   
 /* 
 Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。 
     1，添加。 
         put(K key, V value)  
         putAll(Map<? extends K,? extends V> m)  
  
     2，删除。 
         clear()  
         remove(Object key)  
  
     3，判断。 
         containsValue(Object value)  
         containsKey(Object key)  
         isEmpty()  
  
  
     4，获取。 
         get(Object key)  
         size()  
         values()  
  
         entrySet()  
         keySet()  
  
 Map 
     |--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。 
     |--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。 
     |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。 
  
  
 和Set很像。 
 其实大家，Set底层就是使用了Map集合。 
  
  
 */  
 import java.util.*;  
 class  MapDemo  
 {  
     public static void main(String[] args)   
     {  
         Map<String,String> map = new HashMap<String,String>();  
   
         //添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。  
         //并put方法会返回被覆盖的值。  
         System.out.println("put:"+map.put("01","zhangsan1"));  
         System.out.println("put:"+map.put("01","wnagwu"));  
         map.put("02","zhangsan2");  
         map.put("03","zhangsan3");  
   
         System.out.println("containsKey:"+map.containsKey("022"));  
         //System.out.println("remove:"+map.remove("02"));  
   
         System.out.println("get:"+map.get("023"));  
   
         map.put("04",null);  
         System.out.println("get:"+map.get("04"));  
         //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。  
   
   
           
         //获取map集合中所有的值。  
         Collection<String> coll = map.values();  
   
         System.out.println(coll);  
         System.out.println(map);  
   
   
     }  
 }  

[java]view plaincopy 
   
 /* 
 map集合的两种取出方式： 
 1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。 
     所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。 
          
  
     Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。 
  
  
 2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中， 
                 而这个关系的数据类型就是：Map.Entry 
  
                 Entry其实就是Map中的一个static内部接口。 
                 为什么要定义在内部呢？ 
                 因为只有有了Map集合，有了键值对，才会有键值的映射关系。 
                 关系属于Map集合中的一个内部事物。 
                 而且该事物在直接访问Map集合中的元素。 
  
 */  
   
 import java.util.*;  
   
   
 class MapDemo2   
 {  
     public static void main(String[] args)   
     {  
         Map<String,String> map = new HashMap<String,String>();  
   
         map.put("02","zhangsan2");  
         map.put("03","zhangsan3");  
         map.put("01","zhangsan1");  
         map.put("04","zhangsan4");  
   
         //将Map集合中的映射关系取出。存入到Set集合中。  
         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();  
             String key = me.getKey();  
             String value = me.getValue();  
   
             System.out.println(key+":"+value);  
   
         }  
   
         /* 
         //先获取map集合的所有键的Set集合,keySet(); 
         Set<String> keySet = map.keySet(); 
  
         //有了Set集合。就可以获取其迭代器。 
         Iterator<String> it = keySet.iterator(); 
  
         while(it.hasNext()) 
         { 
             String key = it.next(); 
             //有了键可以通过map集合的get方法获取其对应的值。 
             String value  = map.get(key); 
             System.out.println("key:"+key+",value:"+value); 
         } 
  
         */  
   
     }  
 }  
   
   
 /* 
 Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。 
  
  
  
  
 interface Map 
 { 
     public static interface Entry 
     { 
         public abstract Object getKey(); 
         public abstract Object getValue(); 
  
     } 
 } 
  
 class HashMap implements Map 
 { 
     class Hahs implements Map.Entry 
     { 
         public  Object getKey(){} 
         public  Object getValue(){} 
     } 
      
 } 
 */  

keySet方法图例：

entrySet方法图例：

[java]view plaincopy 
   
 /* 
 map扩展知识。 
  
 map集合被使用是因为具备映射关系。 
  
 "yureban"   Student("01" "zhangsan"); 
  
 "yureban" Student("02" "lisi"); 
  
 "jiuyeban" "01" "wangwu"; 
 "jiuyeban" "02" "zhaoliu"; 
  
 一个学校有多个教室。每一个教室都有名称。 
  
  
 */  
 import java.util.*;  
   
 class Student  
 {  
     private String id;  
     private String name;  
     Student(String id,String name)  
     {  
         this.id = id;  
         this.name = name;  
     }  
     public String toString()  
     {  
         return id+":::"+name;  
     }  
 }  
 class  MapDemo3  
 {  
   
     public static void demo()  
     {  
         HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();  
   
         List<Student> reyu = new ArrayList<Student>();  
         List<Student> jiuye = new ArrayList<Student>();  
   
         czbk.put("yureban",reyu);  
         czbk.put("jiuyeban",jiuye);  
   
         reyu.add(new Student("01","zhagnsa"));  
         reyu.add(new Student("04","wangwu"));  
         jiuye.add(new Student("01","zhouqi"));  
         jiuye.add(new Student("02","zhaoli"));  
   
   
         Iterator<String> it = czbk.keySet().iterator();  
   
         while(it.hasNext())  
         {  
             String roomName = it.next();  
             List<Student> room = czbk.get(roomName);  
               
             System.out.println(roomName);  
             getInfos(room);  
         }  
   
           
   
       
     }  
     public static void getInfos(List<Student> list)  
     {  
         Iterator<Student> it = list.iterator();  
         while(it.hasNext())  
         {  
             Student s = it.next();  
             System.out.println(s);  
         }  
     }  
   
   
   
   
     public static void main(String[] args)   
     {  
          demo();  
           
         /* 
         HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>(); 
  
         HashMap<String,String> yure = new HashMap<String,String>(); 
          
         HashMap<String,String> jiuye = new HashMap<String,String>(); 
  
         czbk.put("yureban",yure); 
         czbk.put("jiuyeban",jiuye); 
  
  
         yure.put("01","zhagnsan"); 
         yure.put("02","lisi"); 
  
         jiuye.put("01","zhaoliu"); 
         jiuye.put("02","wangwu"); 
  
  
  
         //遍历czbk集合。获取所有的教室。 
         Iterator<String> it = czbk.keySet().iterator(); 
  
         while(it.hasNext()) 
         { 
             String roomName = it.next(); 
             HashMap<String,String> room = czbk.get(roomName); 
              
             System.out.println(roomName); 
             getStudentInfo(room); 
         } 
  
          
 //      getStudentInfo(jiuye); 
 //      getStudentInfo(yure); 
 */  
           
     }  
     public static void getStudentInfo(HashMap<String,String> roomMap)  
     {  
         Iterator<String> it = roomMap.keySet().iterator();  
   
         while(it.hasNext())  
         {  
             String id = it.next();  
             String name = roomMap.get(id);  
             System.out.println(id+":"+name);  
         }  
     }  
 }  

Map相关练习：

[java]view plaincopy 
   
 /* 
 每一个学生都有对应的归属地。 
 学生Student，地址String。 
 学生属性：姓名，年龄。 
 注意：姓名和年龄相同的视为同一个学生。 
 保证学生的唯一性。 
  
  
  
 1，描述学生。 
  
 2，定义map容器。将学生作为键，地址作为值。存入。 
  
 3，获取map集合中的元素。 
  
 */  
   
 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)  
     {  
         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*34;  
     }  
     public boolean equals(Object obj)  
     {  
         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("lisi1",21),"beijing");  
         hm.put(new Student("lisi1",21),"tianjin");  
         hm.put(new Student("lisi2",22),"shanghai");  
         hm.put(new Student("lisi3",23),"nanjing");  
         hm.put(new Student("lisi4",24),"wuhan");  
   
         //第一种取出方式 keySet  
   
         Set<Student> keySet = hm.keySet();  
   
         Iterator<Student> it = keySet.iterator();  
   
         while(it.hasNext())  
         {  
             Student stu = it.next();  
             String addr = hm.get(stu);  
             System.out.println(stu+".."+addr);  
         }  
   
   
         //第二种取出方式 entrySet  
         Set<Map.Entry<Student,String>> entrySet = hm.entrySet();  
   
         Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();  
           
         while(iter.hasNext())  
         {  
             Map.Entry<Student,String> me = iter.next();  
             Student stu = me.getKey();  
             String addr = me.getValue();  
             System.out.println(stu+"........."+addr);  
         }  
     }  
 }  

[java]view plaincopy 
   
 /* 
 需求：对学生对象的年龄进行升序排序。 
  
 因为数据是以键值对形式存在的。 
 所以要使用可以排序的Map集合。TreeMap。 
 */  
 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(new Integer(s2.getAge()));  
   
         return num;  
     }  
 }  
   
   
 class  MapTest2  
 {  
     public static void main(String[] args)   
     {  
         TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());  
   
         tm.put(new Student("blisi3",23),"nanjing");  
         tm.put(new Student("lisi1",21),"beijing");  
         tm.put(new Student("alisi4",24),"wuhan");  
         tm.put(new Student("lisi1",21),"tianjin");  
         tm.put(new Student("lisi2",22),"shanghai");  
   
           
         Set<Map.Entry<Student,String>> entrySet = tm.entrySet();  
   
         Iterator<Map.Entry<Student,String>> it = entrySet.iterator();  
   
         while(it.hasNext())  
         {  
             Map.Entry<Student,String> me = it.next();  
   
             Student stu = me.getKey();  
             String addr = me.getValue();  
             System.out.println(stu+":::"+addr);  
         }  
     }  
 }  

[java]view plaincopy 
   
 /* 
 练习： 
 "sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。 
  
 希望打印结果：a(1)c(2)..... 
  
 通过结果发现，每一个字母都有对应的次数。 
 说明字母和次数之间都有映射关系。 
  
 注意了，当发现有映射关系时，可以选择map集合。 
 因为map集合中存放就是映射关系。 
  
  
 什么使用map集合呢？ 
 当数据之间存在这映射关系时，就要先想map集合。 
  
 思路： 
 1，将字符串转换成字符数组。因为要对每一个字母进行操作。 
  
 2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。 
  
 3，遍历字符数组。 
     将每一个字母作为键去查map集合。 
     如果返回null，将该字母和1存入到map集合中。 
     如果返回不是null，说明该字母在map集合已经存在并有对应次数。 
     那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。 
  
 4，将map集合中的数据变成指定的字符串形式返回。 
  
  
  
 */  
 import java.util.*;  
 class  MapTest3  
 {  
     public static void main(String[] args)   
     {  
         String s= charCount("ak+abAf1c,dCkaAbc-defa");  
         System.out.println(s);  
     }  
       
     public static String charCount(String str)  
     {  
         char[] chs = str.toCharArray();  
   
         TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();  
   
           
         int count = 0;  
         for(int x=0; x<chs.length; x++)  
         {  
               
   
             if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))  
                 continue;  
   
             Integer value = tm.get(chs[x]);  
   
               
             if(value!=null)  
                 count = value;  
             count++;  
             tm.put(chs[x],count);//直接往集合中存储字符和数字，为什么可以，因为自动装箱。  
   
             count = 0;  
             /* 
             if(value==null) 
             { 
                 tm.put(chs[x],1); 
             } 
             else 
             { 
                 value = value + 1; 
                 tm.put(chs[x],value); 
             } 
             */  
   
   
         }  
   
         //System.out.println(tm);  
   
         StringBuilder sb = new StringBuilder();  
   
         Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();  
         Iterator<Map.Entry<Character,Integer>>  it = entrySet.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();  
     }  
   
 }  

自动改名

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础之集合框架(三)--Map、HashMap、TreeMap

[java] view plaincopy/* Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。 1，添加。 put(K key, V value) putAll(Map m) 2，删除。 clear() remove(Obje
复制链接

扫一扫

专栏目录