Java学习日志（16-1-Map集合）

约定不等于承诺〃 2022-01-17 07:11 184阅读 0赞

[为什么80%的码农都做不了架构师？>>> ][80_] ![hot3.png][]

Map集合（双列集合）

添加 
    put(K key,V value)
    putAll(Map<?extends K,? extends V>m)
    移除 
    clear()
    remove(Object key)
    判断 
    containsKey(Object key)
    containsValue(Object value)
    isEmpty()
    获取
    get(Object key)
    size()
    values()
    entrySet()**
    keySet()**

该集合存储键值对，一对一对存，而且要保证键的唯一性

三个子类集合

Map
        |--Hashtable:底层是哈希表数据结构，不能存入null键null值，线程同步，效率低
        |--HashMap:底层是哈希表数据结构，可使用null键和null值，该集合不同步，效率高
        |--TreeMap:底层是二叉树数据结构，可以给Map中的键排序，线程不同步
    
    **Set集合底层使用了Map集合

操作练习

import java.util.*;
    class MapDemo{
    	public static void main(String[] args){
    		Map<String,String>map=new HashMap<String,String>();
    		map.put("01","zhangsan1");
    		//相同键存入不同值时，后添加的值会覆盖原有的值，并返回被覆盖的值
    		map.put("02","zhangsan2");
    		map.put("03","zhangsan3");
    		System.out.println("containsKey:"+map.containsKey("02"));
    		// System.out.println("remove:"+map.remove("02"));
    		System.out.println("get:"+map.get("02"));
    		//可以通过get()的返回值来判断一个键是否存在
    		Collection<String>coll=map.values();
    		System.out.println(coll);
    		System.out.println(map);
    	}
    }

map集合的两种取出方式:将map集合转为Set集合，再迭代

Set<k> keySet():将Map所有的键存入到Set集合

利用Set迭代，取出所有的键，在用get取出值

import java.util.*;
    class MapDemo2{
    	public static void main(String[] args){
    		Map<String,String>map=new HashMap<String,String>();
    		map.put("01","zhangsan1");
    		map.put("02","zhangsan2");
    		map.put("03","zhangsan3");
    		map.put("04","zhangsan4");
    		// 获取map中所有键的Set集合
    		Set<String>keySet=map.keySet();
    		// 获取迭代器
    		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);
    		}
    	}
    }

Set<Map.Entry<k,v>> entrySet():将Map集合中的映射关系存入Set集合

而其关系类型为Map.Entry

import java.util.*;
    class MapDemo2{
    	public static void main(String[] args){
    		Map<String,String>map=new HashMap<String,String>();
    		map.put("01","zhangsan1");
    		map.put("02","zhangsan2");
    		map.put("03","zhangsan3");
    		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:"+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 Hash implements Map.Entry{
    		public Object getkey(){};
    		public Object getvalue(){};
    	}
    }

HashMap集合练习

/* 
    每个学生都有对应的归属地
    学生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(){				//覆盖hashCode与equals，保证唯一性
    		 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==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),"bj");
    		 hm.put(new Student("lisi1",21),"tj");
    		 hm.put(new Student("lisi2",22),"sh");
    		 hm.put(new Student("lisi3",23),"cq");
    		 hm.put(new Student("lisi4",24),"hz");
    		 //第一种取出方式
    		 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);
    		 }
    		 //第二种取出方式
    		 Set<Map.Entry<Student,String>>entrySet=hm.entrySet();
    		 Iterator<Map.Entry<Student,String>>it1=entrySet.iterator();
    		 while(it1.hasNext()){
    			 Map.Entry<Student,String>me=it1.next();
    			 Student stu=me.getKey();
    			 String addr=me.getValue();
    			 System.out.println(stu+".."+addr);
    		 }
    	 }
     }

TreeMap集合练习

排序练习

/* 
    按学生姓名排序
    使用有排序功能的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("alisi2",22),"bj");
    		 tm.put(new Student("lisi1",21),"sh");
    		 tm.put(new Student("blisi3",23),"cq");
    		 tm.put(new Student("lisi4",24),"hz");
    		 
    		 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);
    		 }
    	 }
     }

获取字母出现次数

/* 
    sdfgzxcvasdfxcvdf
    获取该字符串中字符出现的次数
    打印格式: a(1)c(2)...
    
    通过审题发现，每一个字母都有对应的次数
    说明字母和次数之间都用映射关系
    
    用a字母作为键去找集合，返回为null，则将a和1存入集合
    如果指定的键已经存在，就将次数取出，自增后重新存入集合
    
    **有映射关系时，采用Map集合
    
    1.将字符串转换成字符数组
    2.定义一个Map集合，有顺序使用TreeMap
    3.遍历字符数组，将字母作为键contains集合
    	返回null则存入，value为1，
    	返回!null，则将value取出自增后存入
    4.将Map集合按指定格式返回
     */
     import java.util.*;
     class MapTest3{
    	 public static void main(String[] args){
    		 String s=charCount("aaa+b-b+bccdeeefavc");
    		 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;	//count需要清零
    /* 			 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();
    	 }
     }

Map扩展知识--一对多映射/集合嵌套

/* 
    Map扩展知识	一对多映射
    Map集合被使用是因为具备映射关系
    "yureban" "01" "zhangsan"
    "yureban" "02" "lisi"
    "jiuyeban" "01" "wangwu"
    "jiuyeban" "02" "zhaoliu"
    一个学校有多个教室，每个教室都有名称
     */
     
    import java.util.*;
    class MapTest4{
    	public static void main(String[] args){
    		HashMap<String,HashMap<String,String>>czbk=new HashMap<String,HashMap<String,String>>();
    		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","zhangsan");
    		yure.put("02","lisi");
    		
    		jiuye.put("01","wangwu");
    		jiuye.put("02","zhaoliu");
    		//遍历czbk集合，获取所有教室
    		Iterator<String>it=czbk.keySet().iterator();
    		while(it.hasNext()){
    			String roomName=it.next();
    			HashMap<String,String>room=czbk.get(roomName);
    			getStuInfo(room);
    		}
    		// getStuInfo(yure);
    	}
    	public static void getStuInfo(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);
    		}
    	}
    }

在开发中学生姓名与学号通常封装为一个对象，因此常用List嵌套

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 MapTest4{
    	public static void mDemo(){
    		HashMap<String,List<Student>>czbk=new HashMap<String,List<Student>>();
    		List<Student>yure=new ArrayList<Student>();
    		List<Student>jiuye=new ArrayList<Student>();
    		
    		czbk.put("yureban",yure);
    		czbk.put("jiuyeban",jiuye);
    		
    		yure.add(new Student("01","zhangsan"));
    		yure.add(new Student("02","lisi"));
    		jiuye.add(new Student("01","wangwu"));
    		jiuye.add(new Student("02","zhaoliu"));
    
    
    		Iterator<String>it=czbk.keySet().iterator();
    		while(it.hasNext()){
    			String roomName=it.next();
    			List<Student>room=czbk.get(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){
            mDemo();
    	}
    }

转载于:https://my.oschina.net/Almon/blog/740065

[80_]: https://my.oschina.net/u/2663968/blog/3051541
[hot3.png]: /images/20220117/672dde826772418daf0fb24e303c8981.png