Map集合练习小习题

Map集合的练习

练习一:统计字符串中,每个字符串出现的次数

需求,已知一个字符串

结果:a出现几次,b出现几次,c出现几次,1出现几次,2出现几次

package maptest;

import java.util.HashMap;
import java.util.Map;

/*
 * 统计字符串出现次数
 * 1.创建字符串
 * 2.转数组
 * 3定义Map集合,键是字符,值出现的次数
 * 4.数组遍历,取出每个数组
 * 5数组的元素字符,到集合中找对应的值
     A:找不到= null
             字符做为键,1做为值,存储回集合
     B:找到了!= null
             字 符做为键，找到值++，做为值,存储回集合
      6.遍历Map集合
 */
public class Test01 {

	public static void main(String[] args) {
    //定义字符串
		String str1="asasdadasdsda12344fdfs2211";
		//转数组
		char [] arr=str1.toCharArray();
		//定义Map集合键是字符,值是出现次数
 Map<Character, Integer> map=new HashMap<Character, Integer>();
     //遍历数组,取出每个元素
   for( char c:arr) {
	   //取出数组元素字符,到集合中找到对应的值
	   Integer value=map.get(c);
	   if (value==null) {
		map.put(c, 1);
	}else {
		//找到了!=null,值++,value++
		value++;
		map.put(c, value);
	    }
      }
   System.out.println(map);
   //遍历输出
   for(Character key:map.keySet() ) {
	   Integer valueInteger=map.get(key);
	   System.out.println("字符"+key+"出现了"+valueInteger+"次");
   }
	}

}

练习二:集合嵌套

• List嵌套List

package maptest;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
 * 集合嵌套
 * 把一个集合存储到另一个集合中
 * 要求ArrayList集合存储字符串
   ArrayList集合,存储那个存储字符串的集合
 */
public class Test02 {

	public static void main(String[] args) {
		//创建集合,存储字符串
		List<String> smallList=new ArrayList<String>();
		smallList.add("a");
		smallList.add("b");
		smallList.add("c");
		List<String> smallList1=new ArrayList<String>();
		smallList.add("a1");
		smallList.add("b2");
		smallList.add("c2");
         //创建集合,存储小集合
		List<List<String>> bigList=new ArrayList<List<String>>();
		bigList.add(smallList);
		bigList.add(smallList1);
		inter(bigList);
	}
	/*
	 * 遍历大集合
	 */
     public static void inter(List<List<String>> bigList) {
    	 //迭代器遍历大集合
    	 Iterator<List<String>> bigiterator=bigList.iterator();
    	 while (bigiterator.hasNext()) {
             List<String> smallList=bigiterator.next();//这是一个小集合需要集合接收
          //迭代器遍历小集合
             Iterator<String> smallIterator=smallList.iterator();
             while (smallIterator.hasNext()) {
				//小集合 String 类型
            	 String s1=smallIterator.next();
            	 System.out.println(s1);
				
			}
		}
     }
}

• List套Map

package maptest;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/*
 * list集合存储Mma集合
 */
public class Test03 {

	public static void main(String[] args) {
	//创建Map集合存储字符串
		Map<String, String>smallMap=new HashMap<String, String>();
		smallMap.put("a", "1");
		smallMap.put("b", "2");
		smallMap.put("c", "3");
		smallMap.put("d", "4");
		Map<String, String>smallMap1=new HashMap<String, String>();
		smallMap.put("e", "1");
		smallMap.put("f", "2");
		smallMap.put("g", "3");
		smallMap.put("h", "4");
		//创建List集合存储Map
		List<Map<String, String>> bigList=new ArrayList<Map<String,String>>();
		bigList.add(smallMap);
		bigList.add(smallMap1);
		inter(bigList);
	}
    /*
     *  遍历大集合List
     */
	public static void inter(List<Map<String, String>> bigList) { 
//迭代器遍历List集合
		Iterator<Map<String, String>> bigit= bigList.iterator();
	while (bigit.hasNext()) {
		//取出list集合元素
		Map<String, String> map=bigit.next();//集合元素是Map集合
		//遍历MA集合,keyset()方法
		Set<String>set=map.keySet();
		//迭代器遍历Set集合
		 Iterator<String>setit=set.iterator();
		 while (setit.hasNext()) {
			 //取出Set集合元素,是Map集合的键
			String keyString=setit.next();
			String valueString=map.get(keyString);
			System.out.println(keyString+"=="+valueString);
			
		}
	}	
   }
}

Map套Map

package maptest;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 * 数据结构:
       Java学科:
                            第一阶段
                                             学生∶学号,姓名
                                             学生∶学号,姓名
                             第二阶段
                                              学生∶学号,姓名
                                               学生∶学号,姓名
 */
public class Test04 {

	public static void main(String[] args) {
		//阶段集合,包含学号,姓名
		Map<String, String>firstMap=new HashMap<String, String>();
		firstMap.put("001", "张三");
		firstMap.put("002", "李四");
		firstMap.put("003", "王五");
		Map<String, String>secondMap=new HashMap<String, String>();
		secondMap.put("004", "赵六");
		secondMap.put("005", "钱七");
		//创建学科集合键是阶段名,值应该是阶段集合
		Map<String, Map<String, String>>javaMap=new HashMap<String, Map<String,String>>();
		javaMap.put("第一", firstMap);
		javaMap.put("第二", secondMap);
		//keySet(javaMap);
		entrySet(javaMap);
	}
	/*
	 * 遍历javaMap集合,keySet()方式
	 */
   public static void keySet(Map<String, Map<String, String>> javaMap) {
	      //学科Map集合遍历方法KeySet()存储键的Set集合
	   Set<String> javaSet=javaMap.keySet();
	   Iterator<String>javaIterator=javaSet.iterator();
	   while (javaIterator.hasNext()) {
		   取出Set集合元素,是javaMap集合的键
		String javaMapkey=javaIterator.next();
		///取出javaMap学科集合的值,值是个阶段的Map集合
		 Map<String, String> jieduanMap=javaMap.get(javaMapkey);
		//遍历阶段的Map集合,调用方法KeySet(),拿出阶段的Map集合
		 Set<String> jieduanSet=jieduanMap.keySet();
		 //迭代器遍历Set集合
		 Iterator<String> jieduanIterator=jieduanSet.iterator();
		 while (jieduanIterator.hasNext()) {
			 //
			String key=jieduanIterator.next();
			//
			String valueString=jieduanMap.get(key);
			System.out.println(javaMapkey+"=="+key+"=="+valueString);
			
		}
	}
	   
   }
   /*
    *  方法遍历javaMap集合,entrySet()方式
    */
   public static void entrySet(Map<String, Map<String, String>> javaMap) {
	 //学科集合javaMap,方法entryset(),获取学科集合的键值对,映射关系对象Entry
   Set<Map.Entry<String, Map<String, String>>>javaMapEntrySet=javaMap.entrySet();
   //迭代器遍历Set集合
    Iterator<Map.Entry<String, Map<String, String>>> javaMapEntryit=javaMapEntrySet.iterator();
    while (javaMapEntryit.hasNext()) {
		///取出Set集合元素,元素是javaMap学科集合的键值对关系对象
		Map.Entry<String, Map<String, String>> javaMapEntry=javaMapEntryit.next();
		//获取//获取javaMap阶段集合的键,是阶段名
		String javaMapkey=javaMapEntry.getKey();
		///获取javaMap集合值,是阶段的集合(姓名,学号)
		Map<String,String> jieDuanMap = javaMapEntry.getValue();
		//遍历阶段jieDuanMap,方法entrySet()取出集合的键值对映射关系对象
		Set<Map.Entry<String,String>> jieDaunEntrySet = jieDuanMap.entrySet(); 
		//迭代器遍历Set
		Iterator<Map. Entry<String, String>> jieDuanEntryIt = jieDaunEntrySet. iterator();
		while(jieDuanEntryIt. hasNext()) {
			//取出Set集合的键,是阶段集合的键值对映射关系对象
			Map . Entry<String, String> jieDuanMapEntry = jieDuanEntryIt .next();
			//阶段集合的键,学号
			String key = jieDuanMapEntry. getKey();
			//阶段集合的值,姓名
			String value = jieDuanMapEntry . getValue();
			System . out. println(javaMapkey+"=="+key+"=="+value); 
		}
	}
}
	}

练习三:斗地主排序

原理:需要自定义顺序
顺序:333344445555…AAAA2222王王
自定义顺序的思想∶编号思想0123…53(数字的自然顺序)
每一个牌(字符串)和编号进行对应,键值对思想实现.编号为键,牌为值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LsCewkFF-1595496182606)(C:\Users\15272\Desktop\笔记\笔记照片\斗地主思想.png)]

package poker;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/*
 * 实现斗地主的排序 
 */
public class PokerMap {

	public static void main(String[] args) {
	//创建Map集合,键是编号.值是存储牌的字符串
		Map<Integer, String> pokerMap=new HashMap<Integer, String>();
		//定义List,存储编号
		List<Integer>pokerList=new ArrayList<Integer>();
		//定义变量,来保存编号
		int index=0;
		//定义花色数组
		String []colors= {"♠","♥","♣","♦"};
		//定义13个点数
		 String [] numbers= {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        //遍历数组,存储花色
		 for(String number:numbers) {
			 for(String color:colors) {
				 //存储到Map集合中
				 pokerMap.put(index, color+number);
				 //编号存储到List集合中
				 pokerList.add(index);
				 index++;
			 }
		 }//存储王牌
		 pokerMap.put(52, "小🃏");
		 pokerMap.put(53, "🃏");
		 pokerList.add(52);
		 pokerList.add(53);
		// System.out.println(pokerMap);
		 //System.out.println();
		 //存储编号的List,元素随机排列
		 Collections.shuffle(pokerList);
		 //定义四个集合List 3个玩家和底牌
		 List<Integer>player1=new ArrayList<Integer>();
		 List<Integer>player2=new ArrayList<Integer>();
		 List<Integer>player3=new ArrayList<Integer>();
		 List<Integer>dipai=new ArrayList<Integer>();
		 //循环遍历,存储编号的集合,进行发牌
		 for (int i = 0; i < pokerList.size(); i++) {
			 //发底牌
			 if (i<3) {
				dipai.add(i);
			}
			 //分别给三个玩家发牌
				 else  if   (i%3==0) {
						player1.add(i);
					 }
				  else if (i%3==1) {
						 player2.add(i);
					 }
				  else if (i%3==2) {
						 player3.add(i);
					 }
			 //玩家集合 ,牌序号的排列
		}
		  Collections.sort(player1,Collections. reverseOrder());
			 Collections.sort(player2,Collections. reverseOrder());
			 Collections.sort(player3,Collections. reverseOrder());
			 Collections.sort(dipai);
			 //看牌 ,把玩家集合中的编号,作为键,到Map集合中找值
			 look("玩家1",pokerMap,player1);	
			   look("玩家2",pokerMap,player2);
			   look("玩家三",pokerMap,player3);
			   look("底牌",pokerMap,dipai);
	}
	/*
	 * 定义看牌方法:遍历集合
	 * 需要编号集合,需要存储牌的Map集合
	 */
		 public static void  look(String name,Map<Integer, String> map ,List<Integer> list ) {
	 System.out.print(name+":");
	 for (Integer key:list) {
		String valueString=map.get(key);
		System.out.print(valueString+" ");
	}
	 System.out.println();
   }
}