Map集合概述特点、基本功能、获取方法、遍历方法（三种）、ArrayList集合嵌套HashMap集合实例、Collections常用方法（附两个斗地主实现案例）

Interface Map< K,V >

所在包：java.util
	K-由此地图维护的键的类型
	V-映射值的类型
public interface Map<K,V>

特点：

• 将键映射到值的对象。地图不能包含重复的键
• 每个键可以映射到最多一个值

创建对象格式：

• 多态创建Map集合对象
• 实现类使用HashMap

Map集合的常用方法：

代码示例：

Map<String,String> map = new HashMap<String,String>();
map.put("001","张三")；
map.put("002","李四")；
map.put("003","王五")；
System.out.print(map);
输出结果：
	{
   001=张三 , 002=李四 , 003=王五}

Map集合的获取方法

代码示例：

public static void main(String[] args){
   
	Map<Integer,String> map = new HashMap<Integer,String>();
	map.put(100,"hello");             
//注意：Map.put(K,V);在存入数据时K一样而V不同时，后面存入的V会将前面已经存入的V给覆盖掉（键相同值覆盖）
	map.put(20,"world");                         
//一般键相同但没有出现值覆盖的原因一般是 对象类作为Key中没有重写equals()和hashCode()方法，
//在类中利用Alt+Insert自动重写即可
	map.put(30,"java");
	Set<Integer>s=map.keySet();                     
//调用keySet()方法 返回值为Set<K>
	System.out.println(map.get(100));      
//调用get()方法 返回值为V
	for(Integer i:s){
   
		System.out.println(i);
	}
	Collection<String> s1 = map.values();    
//调用values()方法 返回值为Collection<V>
	for(String s0:s1){
   
		System.out.println(s0);
	}
}
输出结果：
hello
100
20
30
hello
world
java

Map集合的遍历（三种方法）

方法一：

普遍使用，二次取值操作
	Map<Integer,String> map=new HashMap<Integer,String>();
	map.put(1,"hello");
	map.put(2,"world");
	map.put(3,"java");
	for(Integer i:map.keySet()){
            //利用keySet()和增强for遍历key和value
		System.out.print(i+","+map.get(i));
	}

方法二：

通过Map.entrySet使用iterator遍历key和value
	…(省略初始化赋值操作)
	Set<Map.Entry<Integer,String>> entry=map.entrySet();
	Interator<Map.Entry<Integer,String>> it = entry.iterator();     
	//entrySet()的返回值是Set<Map.Entry<K,V>>，该值带有iterator()迭代器方法
	While(it.hasNext()){
   
		Map.Entry<Integer,String> next=it.next();      
		//Map.Entry<K,V>是单独的一种引用数据类型
		Integer key=next.getKey();
		String value=next.getValue();
		System.out.print(key + " , " + value);
	}

方法三：

通过Map.entrySet遍历key和value，（大容量时推荐）
	…(省略初始化赋值操作)
	for(Map.Entry<Integer,String> me : map.entrySet()){
             
	//直接利用增强for遍历获取的map.entrySet()键值对象集合
		Integer key=me.getKey();                         
	//再利用Map.Entry<K,V>自带的getKey()和getValue()方法获取键、值。
		String value=me.getValue();
		System.out.print(key+","+value);
	}

ArrayList集合嵌套HashMap集合实例(三个小题目)

题目一：
创建一个ArrayList集合，存储三个元素，每个元素都是HashMap，每个HashMap的键和值都是String，并遍历。
代码示例：

public static void main(String[] args){
   
	ArrayList<HashMap<String,String>>d=newArrayList<HashMap<String,String>>();     
	//创建ArrayList集合
	HashMap<String,String> t1 = new HashMap<String,String>();                              
	//创建HashMap集合
	HashMap<String,String> t2 = new HashMap<String,String>();
	HashMap<String,String> t3 = new HashMap<String,String>();
	t1.put("01","hello");
	t1.put("02","world");
	t2.put("03","hello");
	t2.put("04","world");
	t3.put("05","hello");
	t3.put("06","world");
	d.add(t1);         //把HashMap集合作为元素添加到ArrayList集合中
	d.add(t2);
	d.add(t3);
	for(HashMap<String,String>s:d){
               //遍历ArrayList集合
		for(String me : s.keySet()){
               
	//用s.entrySet()方法或者s.keySet()方法都可，数据量比较小时建议使用keySet()
			String value = s.get(me);
			System.out.print(me+","+value+"");
		}
		System.out.println();
	}
}

题目2：
创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList，每一个ArrayList的元素的String，并遍历。
代码示例：

public static void main(String[] args){
   
	HashMap<String,ArrayList<String>> map = new HashMap<String,ArrayList<String>>();   
	//创建HashMap集合
	ArrayList<String> s1 = new ArrayList<String>();                               
	//创建ArrayList集合，并添加元素
	ArrayList<String> s2 = new ArrayList<String>();
	ArrayList<String> s3 = new ArrayList<String>();
	s1.add("hello");
	s1.add("001");
	s2.add("wordl");
	s2.add("002");
	s3.add("java");
	s3.add("003");
	map.put("01",s1);                                       
	//把ArrayList作为元素添加到HashMap集合
	map.put("02",s2);
	map.put("03",s3);
	for(Map.Entry<String,ArrayList<String>>me:map.entrySet()){
              
	//遍历HashMap集合
		String key=me.getKey();
		ArrayList<String> value = me.getValue();
		System.out.print(key+",");
		for(Strings:value){
   
			System.out.print(s+"");
		}
		System.out.println();
	}
}

题目3：键盘录入一个字符串，要求统计字符串中每个字符出现的次数
举例：键盘录入“aababcabcdabcde” 输出：“a5 b4 c3 d2 e1”
代码示例：

public static void main(String[] args){
   
	Scanner sc = new Scanner(System.in);          //创建输入流
	Map<Character,Integer> map = new HashMap<Character,Integer>();    
	//创键HashMap集合，键是Character，值是Integer
	String s = sc.nextLine();
	for(inti=0;i<s.length();i++){
                 //遍历每个字符
		char c = s.charAt(i);          
		Integer value = map.get(c);       
		//get得到value的值，在Map集合中get没有得到值则返回null
		if( value == null ){
                  
		//返回null说明Map集合中还没有存储该字符串
			map.put(c,1);            
		//将该字符串put进Map中并将value赋上初值1 表示该字符出现了一次
		}else{
   
			value++;                   
//value不是null则表明该字符在Map中出现过了，再出现则令value++，并将新的value值put进Map集合中
			map.put(c,value);
		}
	}
	StringBuilder sb = new StringBuilder();     
	//初始化StringBuilder类型用于字符串拼接
	for(Map.Entry<Character,Integer> me : map.entrySet()){
            //遍历Map集合
		Character key = me.getKey();
		Integer value = me.getValue();
		sb.append(key).append(value).append("");                
		//利用StringBuilder集合中append方法实现字符串拼接
	}
	String result = sb.toString();                 
	//用toString方法将StringBuilder转换为String类型
	System.out.println(result);                 
}

Collection常用方法：针对集合操作的工具类

所在包：java.util 
public class Collections 
	 extends Object

常用方法：

关于集合升序的方法：
代码示例：

升序：
List<Integer> list = Arrays.asList(2,5,3,6,0,1,4);
	Collections.sort(list);
	System.out.print(list);
输出结果：
	[0,1,2,3,4,5,6]
-------------------------------------------------------------------------------------------------
降序：
List<Integer> list = Arrays.asList(2,5,3,6,0,1,4);
	Collections.sort( list , new Comparator<Integer>(){
   
		@Override
		public int compare(Integer o1,Integer o2){
   
			return o2-o1;        
		//o2-o1时逆序存入、o1-o2时升序存入、return 1时按存入顺序输出、return -1时按存入顺序逆输出
		}
	})
	System.out.print(list);
输出结果：
	[6,5,4,3,2,1,0]

模拟斗地主案例1（普通）

要求：通过程序实现斗地主过程中的洗牌，发牌和看牌
思路：
1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
2.往牌盒里装牌
3.洗牌，也就是把牌打散，利用Collection中的shuffle()方法实现
4.发牌，也就是遍历集合，给三个玩家发牌
5.看牌，也就是三个玩家分别遍历自己的牌
代码示例：

public static void main(String[] args){
   
	ArrayList<String> t = new ArrayList<String>();               
	//创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
	String[] h = {
   "♣","♥","♠","♦"};
	String[] p = {
   "2","3","4","5","6","7","8","9","10","J","Q","K","A"};
	for(Stringi:h){
   
		for(Stringj:p){
   
			t.add(i+j);            //往牌盒里装牌
		}
	}
	t.add("大王");
	t.add("小王");
	Collections.shuffle(t);                          
	//洗牌，也就是把牌打散，利用Collection中的shuffle()方法实现
	ArrayList<String> t1 = new ArrayList<String>();
	ArrayList<String> t2 = new ArrayList<String>();
	ArrayList<String> t3 = new ArrayList<String>();
	ArrayList<String> dp = new ArrayList<String>();
	for(int i=0;i<t.size();i++){
                     //发牌，也就是遍历集合，给三个玩家发牌
		String s=t.get(i);
		if(i>=t.size()-3){
   
			dp.add(s);
		}else if(i%3==0){
   
			t1.add(s);
		}else if(i%3==1){
   
			t2.add(s);
		}else{
   
		t3.add(s);
		}
	}
	poker("t1",t1);                   //调用看牌方法
	poker("t2",t2);
	poker("t3",t3);
	poker("dp",dp);
	}
public static void poker(String name,ArrayList<String> list){
                  
//看牌，也就是三个玩家分别遍历自己的牌
	System.out.print(name+":");
	for(String i:list){
   
		System.out.print(i+" ");
	}
	System.out.println();
}

模拟斗地主案例2（优化）

需求：通过程序实现斗地主过程中的洗牌，发牌和看牌。要求：对牌进行排序
思路：
1.创建HashMap，键是编号，值是牌
2.创建ArrayList，存入编号
3.创建花色数组和点数数组
4.从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
5.洗牌（洗的是编号），用Collection.shuffle()方法进行随机排序
6.发牌（发的是编号，为了保证编号是排序的，创建TreeSet集合接收）
7.定义方法看牌（遍历TreeSet集合，获取编号，到HashMap集合中找对应的牌）
8.调用查看方法
代码示例：

public static void main(String[] args){
   
	String[] h = {
   "♣","♥","♠","♦"};             
	//创建花色数组和点数数组
	String[] p = {
   "3","4","5","6","7","8","9","10","J","Q","K","A","2"};
	HashMap<Integer,String> map = new HashMap<Integer,String>();    
	//创建HashMap，键是编号，值是牌
	ArrayList<Integer> temp = new ArrayList<Integer>();         
	//创建ArrayList，存入编号
	
	int ans = 0;
	for(String i:p){
   
		for(String j:h){
   
			map.put(ans,i+j);                 
			//从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
			temp.add(ans);        
			ans++;
		}
	}
	map.put(ans,"大王");
	temp.add(ans++);
	map.put(ans,"小王");
	temp.add(ans);
	Collections.shuffle(temp);          
	//**洗牌（洗的是编号），用Collection.shuffle()方法进行随机排序**
	
	TreeSet<Integer> p1 = new TreeSet<Integer>();       
	TreeSet<Integer> p2 = new TreeSet<Integer>();
	TreeSet<Integer> p3 = new TreeSet<Integer>();
	TreeSet<Integer> dp = new TreeSet<Integer>();
	for(int i = 0;i<temp.size();i++){
                  
	//发牌（发的是编号，为了保证编号是排序的，创建TreeSet集合接收）
		if(i>=temp.size()-3){
   
			dp.add(temp.get(i));
		}else if(i%3==0){
   
			p1.add(temp.get(i));
		}else if(i%2==0){
   
			p2.add(temp.get(i));
		}else{
   
			p3.add(temp.get(i));
		}
	}
	show("张三",p1,map);            //调用查看方法
	show("李四",p2,map);
	show("王五",p3,map);
	show("底牌",dp,map);
}
		
Public static void show(String name,TreeSet<Integer> tree,HashMap<Integer,String> map){
             
//定义方法看牌（遍历TreeSet集合，获取编号，到HashMap集合中找对应的牌）
	System.out.print(name+":");
	for(Integer i:tree){
   
		System.out.print(map.get(i)+" ");
	}
	System.out.println();
}