20_集合_第20天（Map、可变参数、Collections）_讲义（复习）

package cn.itcast.demo011;

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

/*
 * Map接口中的常用方法
 * 		使用Map接口的实现类的HashMap
 */
public class MapDemo {
	public static void main(String[] args) {
		System.out.println("========function()========");
		function();
 		System.out.println("======function_1()=========");
		function_1();
		System.out.println("======function_2()========");
		function_2();
	}
	/*
	 * 将键值对存储到集合中
	 *  V put(K key, V value) 
                将指定的值与此映射中的指定键关联（可选操作）
        K:键的对象  V:值的对象
              存储的是重复的键,将原来的值,覆盖,值可以重复,键不允许
               返回值一般情况下返回null
               存储重复键,返回被覆盖之前的值
	 */
	public static void function_2() {
		//创建集合对象,作为键的对象整数,值的对象存储到字符串
		Map<Integer, String> map = new HashMap<Integer,String>();
		String s1 = map.put(1, "a");
		//返回值一般情况下返回null
		System.out.println(s1);
		
		//存储重复键,返回被覆盖的值
		//并且重复键,被后续值替换
		String s2 = map.put(1, "b");
		System.out.println(s2);
	
	}
	/*
	 * 通过键对象,获取值对象
	 *  V get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
	 *  V - 对应键的值
	 */
	public static void function_1() {
		//创建集合对象,作为键的对象整数,值的对象存储到字符串
		Map<Integer, String> map = new HashMap<Integer,String>();
		map.put(1, "a");
		map.put(2, "b");
		map.put(3, "c");
		System.out.println(map);

		
		String value = map.get(1);
		System.out.println(value);
	}
	/*
	 * 移除集合中的键值对,返回被移除之前的值
	 * public interface Map<K,V>
	 * V remove(Object key)  如果存在一个键的映射关系，则将其从此映射中移除（可选操作）
	 */
	public static void function(){
		//创建集合对象,作为键的对象整数,值的对象存储到字符串
		Map<Integer, String> map = new HashMap<Integer,String>();
		map.put(1, "a");
		map.put(2, "b");
		map.put(3, "c");
		System.out.println(map);

		
		String value = map.remove(1);
		System.out.println(value);
		

		System.out.println(map);
	}
}

package cn.itcast.demo011;

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

/*
 * 1.4	Map集合遍历键找值方式
 * 		1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键
 *		2.遍历键的Set集合，得到每一个键
 *		3.根据键，获取键所对应的值

 * Map集合的遍历
 * 		利用键获取值
 * 		Map接口中定义方法keySet
 * 所有的键,存储到Set集合
 */
public class MapDemo01 {
	public static void main(String[] args) {
		/*
		 * Map集合中键不能进行遍历,故采用Map集合的方法keySet(),转成Set集合,才能遍历
		 * getClass()（Object类的方法,意味着每个子类都有这个方法）返回这个类的全名
		 * 
		 * 1.调用Map集合的方法keySet(),所有的键存储到Set集合中
		 * 2.遍历Set集合,获取Set集合中所有的元素(Map中的键)(可以用迭代器或者增强for循环来遍历)
		 * 3.调用Map集合方法 V get(Object key) ,通过键获取到值
		 */
		Map<String, Integer> map = new HashMap<String,Integer>();
		map.put("a", 11);
		map.put("b", 12);
		map.put("c", 13);
		
		//1.调用Map集合的方法keySet(),所有的键存储到Set集合中
		Set<String> set = map.keySet();
		//[b, c, a]
		System.out.println(set);
		System.out.println("======================");
		//class java.util.HashMap$KeySet
		//getClass()（Object类的方法,意味着每个子类都有这个方法）返回这个类的全名
		System.out.println(set.getClass());
		System.out.println("======================");
		//2.遍历Set集合,获取Set集合中所有的元素(Map中的键)
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			//it.next()返回Set集合元素,也就是Map中的键
			//3.调用Map集合方法 V get(Object key) ,通过键获取到值
			String key = it.next();
			Integer value = map.get(key);
			System.out.println(key + "..." + value);
		}
		//使用增强for循环来遍历Set集合,可发现增强for循环更加简洁
		//但是其实增强for循环编译后就是迭代器
		//增强for循环语法：
		//type-数据类型  element-数据类型的临时变量 array-集合容器的变量名
		//for(type element: array)
		//{
		//	System.out.println(element);
		//}
		System.out.println("======================");
		//for(String key : set){
		for(String key : map.keySet()){
			Integer value = map.get(key);
			System.out.println(key + "..." + value);
		}
	}
}

package cn.itcast.demo011;

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

/*
 * 基于哈希表的 Map 接口的实现。
 * 此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
 * （除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）
 * 此类不保证映射的顺序，特别是它不保证该顺序恒久不变
 * Map集合Entry对象
 * Map集合获取方法
 * entrySet方法,键值对映射关系（结婚证）获取
 * 实现步骤：
 * 		1.调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
 * 			Set<Map.Entry<K,V>> entrySet()  
 * 		2.迭代Set集合
 * 		3.获取出的Set集合的元素,是映射关系对象
 * 		4.通过映射关系对象方法getKey,getValue获取键值对
 * 创建内部类对象: 外部类.内部类 = new
 * 创建内部接口对象：外部接口.内部接口
 */
public class MapDemo02 {
	public static void main(String[] args) {
		//Map中常用的集合（已知实现类）为HashMap集合、LinkedHashMap集合
		Map<Integer, String> map = new HashMap<Integer,String>();
		//V put(K key, V value) 
		//将指定的值与此映射中的指定键关联（可选操作）
		map.put(2, "b");
		map.put(1, "a");
		map.put(3, "c");
		//1.调用map集合方法entrySet()将集合中的 键值对映射关系 对象,存储到Set集合
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		//getClass()（Object类的方法,意味着每个子类都有这个方法）返回这个类的全名
		//class java.util.HashMap$EntrySet
		System.out.println(set.getClass());
		System.out.println("========================");
		//[1=a, 2=b, 3=c]
		System.out.println(set);
		System.out.println("========================");
		//2.迭代Set集合
		Iterator<Map.Entry<Integer, String>> it = set.iterator();
		while(it.hasNext()){
			//3.获取出的Set集合的元素,是映射关系对象
			//it.next()获取的是什么对象,取出来也是Map.Entry 键值对映射关系 对象
			Map.Entry<Integer, String> entry = it.next();
			//4.通过映射关系对象方法getKey,getValue获取键值对
			String value = entry.getValue();
			Integer key = entry.getKey();
			System.out.println(key + "..." + value);
		}
		System.out.println("========================");
		//增强for循环,Iterable接口下所有实现类都能遍历,而Iterable下面子类没有Map
		//我们增强for循环是遍历set,不能遍历Map集合
		//增强for循环语法：
		//type-数据类型  element-数据类型的临时变量 array-集合容器的变量名
		//for(type element: array)
		//{
		//	System.out.println(element);
		//}
		for(Map.Entry<Integer, String> entry : map.entrySet()){
			System.out.println(entry.getKey() + "..." + entry.getValue());
		}
		
	}
}

package cn.itcast.demo022;

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

/*
 * 使用HashMap集合,要求存储自定义的对象
 * 自定义对象,作为键出现,作为值出现
 * 必须保证键的唯一性,需要重写hashCode 和 equals方法
 */
public class HashMapDemo {
	public static void main(String[] args) {
		function();
		System.out.println("==========我是可爱分界线=============");
		function_1();	
	}
	/*
	 * HashMap,存储自定义对象Person,作为值出现
	 * 键对象是字符串,可以保证唯一性
	 */
	public static void function_1(){
		HashMap<String, Person> map = new HashMap<String,Person>();
		map.put("北京", new Person("a",12));
		map.put("上海", new Person("b",13));
		map.put("上海", new Person("b",13));
		map.put("杭州", new Person("c",14));
		//1.调用map集合的方法keySet,所有的键存储到Set集合中
		//2.遍历Set集合,获取Set集合中所有的元素(Map中的键) (可以用迭代器或者增强for循环来遍历Key)
		//Set<K> keySet() 返回此映射中所包含的    键 的 Set 视图 
		for(String key : map.keySet()){
			//3.调用map集合方法get,通过键获取到值
			Person value = map.get(key);
			System.out.println(key + "..." + value);
		}
		System.out.println("=============================");
		//1.调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
		//2.迭代Set集合
		//3.获取出的Set集合的元素,是映射关系对象
		//增强for循环语法：
		//type-集合容器中元素类型  element-集合容器元素类型中的临时变量       array-集合容器的变量名
		//for(type element: array)
		//{
		//	System.out.println(element);
		//}
		for(Map.Entry<String, Person> entry : map.entrySet()){
			//4.通过映射关系对象方法getKey(),getValue()获取键值对
			String key = entry.getKey();
			Person value = entry.getValue();
			System.out.println(key + "..." + value);		
		}
	}
	/*
	 * HashMap存储自定义对象Person,作为键出现
	 * 键对象,是Person类型,值是字符串
	 * 保证键的唯一性,存储到键的对象,需要重写hashCode和equals方法
	 */
	public static void function(){
		HashMap<Person, String> map = new HashMap<Person,String>();
		map.put(new Person("a",12), "南京");
		//保证键的唯一性,存储到键的对象,需要重写hashCode和equals方法
		map.put(new Person("b",13), "上海");
		map.put(new Person("b",13), "上海");
		map.put(new Person("c",14), "杭州");
		// Set<K> keySet() 返回此映射中所包含的    键 的 Set 视图 
		for(Person key : map.keySet()){
			// V get(Object key) 
	        //返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null 
			String value = map.get(key);
			System.out.println(key + "..." + value);
		}
		System.out.println("=============================");
		//Set<Map.Entry<K,V>> entrySet() 返回此映射所包含的    映射关系    的 Set 视图 
		for(Map.Entry<Person, String> entry : map.entrySet()){
			// K getKey() 返回与此项对应的键
	        // V getValue()  返回与此项对应的值 
			System.out.println(entry.getKey() + "..." + entry.getValue());
		}	
	}
}

package cn.itcast.demo03;
/*
 * JDK1.5新特性,静态导入
 * 减少开发的代码量
 * 标准的写法,导入包的时候才能使用
 * 
 * import static java.lang.System.out;最末尾,必须是一个静态成员
 */
import static java.lang.System.out;
import static java.util.Arrays.sort;

public class StaticImportDemo {
	public static void main(String[] args) {
		//System.out.println("hello");
		out.println("hello");
		int[] arr = {1,2};
		//Arrays.sort(arr);
		sort(arr);
	}
}

package cn.itcast.demo02;

import java.util.LinkedHashMap;

/*
 * LinkedHashMap继承HashMap
 * 保证迭代的顺序
 */
public class LinkedHashMapDemo {
	public static void main(String[] args) {
		LinkedHashMap<String, String> link = new LinkedHashMap<String,String>();
		link.put("1", "a");
		link.put("2", "a");
		link.put("3", "a");
		link.put("4", "a");
		System.out.println(link);
		
	}
}

package cn.itcast.demo02;

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

/*
 * Map接口实现类Hashtable
 * 底层数据结果哈希表,特点和HashMap是一样的
 * Hashtable线程安全集合,运行速度慢
 * HasMap线程不安全的集合,运行速度快
 * 
 * Hashtable 命运 和 Vector是一样的,从JDK1.2开始,被更先进的HashMap取代
 * 
 * HashMap允许存储null值,null键
 * Hashtable不允许存储null值,null键
 * 
 * Hashtable他的子类Properties依然活跃在开发舞台
 */
public class HashtableDemo {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String,String>();
		map.put(null, null);
		System.out.println(map);
		
		//Map<String,String> map1 = new Hashtable<String,String>();
		//map1.put(null, null);
		//java.lang.NullPointerException
		//System.out.println(map1);
	}
}

package cn.itcast.demo03;
/*
 * JDK1.5新特性,方法的可变参数
 * 前提:方法参数数据类型确定,参数的个数任意
 * 可变参数语法：数据类型...变量名
 * 可变参数,本质就是一个数组   [I@104c575
 */
public class VarArgumentsDemo {
	public static void main(String[] args) {
		//调用一个带有可变参数的方法,传递参数,可以任意
		System.out.println(getSum());
		System.out.println("=============================");
		System.out.println(getSum(1,1));
		System.out.println("=============================");
		System.out.println(getSum(1,1,1,1,1,1,1,1,1,1));
		System.out.println("=============================");
		System.out.println(getSum(2,3,4));
		
		//function(1,2,3);
	}
	/*
	 * 可变参数的注意事项：
	 * 1.一个方法中,可变参数只能有一个
	 * 2.可变参数,必须写在参数列表的最后一位
	 */
//	public static void function(int...a,int...b){
//		
//	}
//	public static void funtion(int b, int c,int...a){}
	//这么写,后面b,c就没什么用了
//	public static void funtion(int...a,int b, int c){}
	/*
	 * 定义方法,计算十个整数和
	 * 方法的可变参数实现
	 */
	public static int getSum(int...a){
		int sum = 0;
		System.out.println(a);
		System.out.println(a.length);
		for(int i : a){
			sum += i;
		}
		return sum;
	}
	
	/*
     * 定义方法,计算3个整数和
     */
    /*public static int getSum(int a,int b ,int c){
        return a+b+c;
    }*/
    
    /*
     * 定义方法,计算2个整数和
     */
    /*public static int getSum(int a,int b){
        return a+b;
    }*/
}

package cn.itcast.demo04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/*1.10	Collections集合工具类
 * 集合操作的工具类
 *  Collections
 */
public class CollectionDemo {
	public static void main(String[] args) {
		function();
		System.out.println("====================");
		function_1();
		System.out.println("====================");
		function_2();
	}
	/*
	 * Collections.shuffle方法
	 * 对List集合中的元素,进行随机排列
	 */
	public static void function_2(){
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(3);
		list.add(5);
		list.add(7);
		list.add(16);
		System.out.println(list);
		//调用工具类静态方法shuffle方法
		Collections.shuffle(list);
		System.out.println(list);

	}
	/*
	 * Collections.binarySearch静态方法
	 * 对List集合进行二分搜索,方法参数,传递List集合,传递被查找的元素
	 */
	public static void function_1(){
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(3);
		list.add(5);
		list.add(7);
		list.add(16);
		//调用工具类静态方法binarySearch
		int index = Collections.binarySearch(list, 5);
		System.out.println(index);
		//如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
		int index1 = Collections.binarySearch(list, 6);//(-(3)-1)=-4
		System.out.println(index1);
	}
	/*
	 * sort(List<T> list) 
	 * Collections.sort()静态方法
	 * 对于List集合,进行升序排列
	 */
	public static void function(){
		//创建List集合,使用多态来写,扩展性强
		//1)person为父类，student为子类。那么：person p=new student()；
		List<Integer> list = new ArrayList<Integer>();
		list.add(5);
		list.add(4);
		list.add(3);
		list.add(1);
		list.add(2);
		System.out.println(list);
		//调用集合工具类的方法sort()
		Collections.sort(list);
		System.out.println(list);
	}
}

package cn.itcast.demo055;

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

/*
 * Map集合的嵌套,Map中存储的还是Map集合
 * 要求：
 * 		传智播客：
 * 			Java基础班
 * 				001 张三
 * 				002 李四
 * 			Java就业班
 * 				001 王五
 * 				002 赵六
 * 对以上数据进行对象的存储
 * 		001 张三  ==> 键值对关系
 * Java基础班：存储学号和姓名的键值对关系  集合容器
 * Java就业班：存储学号和姓名的键值对关系  集合容器
 * 传智播客：存储的是班级  集合容器
 * 
 * 班级Map <学号,姓名>
 * 传智播客-Map <班级名字,班级Map>
 */
public class MapMapDemo {

	public static void main(String[] args) {
		//定义基础班集合
		HashMap<String, String> javase = new HashMap<String,String>();
		//定义就业班集合
		HashMap<String, String> javaee = new HashMap<String,String>();
		//向班级集合中,存储学生信息
		javase.put("001", "张三");
		javase.put("002", "李四");
		
		javaee.put("001", "王五");
		javaee.put("002", "赵六");
		
		//定义传智播客集合容器,键是班级名字,值是两个班级集合容器
		HashMap<String, HashMap<String, String>> czbk 
		= new HashMap<String,HashMap<String, String>>(); 
		
		czbk.put("Java基础班", javase);
		czbk.put("Java就业班", javaee);
		
		//遍历集合
		entrySet(czbk);
		System.out.println("===========================");
		keySet(czbk);
	}
	public static void keySet(HashMap<String, HashMap<String, String>> czbk){
		//调用czbk集合容器方法keySet()将键存储到Set集合
		Set<String> classNameset = czbk.keySet();
		//classNameSet是一个Set集合容器,String - HashMap<String, String> 
		//classNameSet:[就业班, 基础班]
		//System.out.println("classNameSet:" + classNameSet);
		//迭代器迭代Set集合容器(其中泛型不要自己写,根据上面直接复制或者根据提示)
		Iterator<String> classNameIt = classNameset.iterator();
		while(classNameIt.hasNext()){
			//classNameIt.next()获取出来的是Set集合元素,czbk集合的键
			String classNameKey = classNameIt.next();
			//czbk集合的方法get获取值,值是一个HashMap集合
			HashMap<String, String> classMap = czbk.get(classNameKey);
			//调用classMap集合方法KeySet,键存储到Set集合,进行遍历
			//stuIno是一个Set集合容器,String - String 
			Set<String> stuIno = classMap.keySet();
			//studentIno:[001, 002]
			//System.out.println("studentIno:" + studentIno);
			//迭代基础班集合容器/就业班集合   Set集合容器
			Iterator<String> stuInoIt = stuIno.iterator();
			while(stuInoIt.hasNext()){
				//stuInoIt.next()获取出来的是Set集合元素,classMap集合的键
				String studentID = stuInoIt.next();
				//调用classMap集合中的get方法获取值
				String studentName = classMap.get(studentID);
				System.out.println(classNameKey + "..." + studentID + "..." + studentName);
			}
		}
	}
	public static void entrySet(HashMap<String, HashMap<String, String>> czbk){
		//调用czbk集合容器方法entrySet() 将czbk集合容器的键值对关系对象 存储到Set集合
		Set<Map.Entry<String, HashMap<String, String>>> classNameSet = czbk.entrySet();
		//迭代器迭代Set集合容器(其中泛型不要自己写,根据上面直接复制或者根据提示)
		Iterator<Map.Entry<String, HashMap<String, String>>> classNameIt = classNameSet.iterator();
		while(classNameIt.hasNext()){
			//classNameIt.next()获取的是czbk集合容器的键值对关系对象
			Map.Entry<String, HashMap<String, String>> classNameEntry = classNameIt.next();
			//classNameEntry方法getKey()以及getValue()获取键值对
			String classNameKey = classNameEntry.getKey();
			//获取键对应值,值是一个HashMap集合容器
			HashMap<String, String> classMap = classNameEntry.getValue();
			//调用classMap集合容器方法entrySet(),将classMap集合容器的键值对关系存储到Set集合容器
			//因为HashMap集合的键无法遍历,必须转成Set集合容器,方可遍历
			Set<Map.Entry<String, String>> stuNameSet = classMap.entrySet();
			//迭代器迭代Set集合容器(其中泛型不要自己写,根据上面直接复制或者根据提示)
			Iterator<Map.Entry<String, String>> stuNameIt = stuNameSet.iterator();
			while(stuNameIt.hasNext()){
				//stuNameIt.next()获取的是classMap集合容器的键值对关系对象
				Map.Entry<String, String> stuNameEntry = stuNameIt.next();
				//stuNameEntry方法getKey()以及getValue()获取键值对
				String studentID = stuNameEntry.getKey();
				//获取键对应值,值是String
				String studentName = stuNameEntry.getValue();
				System.out.println(classNameKey + "..." + studentID + "..." + studentName);
			}
		}
	}

}

package cn.itcast.demo066;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

/*
 * 	
 *  准备牌：
	完成数字与纸牌的映射关系：
	使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。
	洗牌：
	通过数字完成洗牌发牌
	发牌：
	将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
	存放的过程中要求数字大小与斗地主规则的大小对应。
	将代表不同纸牌的数字分配给不同的玩家与底牌。
	看牌：
	通过Map集合找到对应字符展示。
	通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。

 * static void shuffle(List<?> list, Random rnd) 
          使用指定的随机源对指定列表进行置换 
          
   sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序
   
   	实现模拟斗地主的功能：
   	1.组合牌
   	2.洗牌
   	3.发牌
   	4.看牌
 */
public class Poker {

	public static void main(String[] args) {
		//1.组合牌
		//创建Map集合,键是编号,值是牌
		HashMap<Integer, String> poker = new HashMap<Integer,String>();
		//创建List集合,存储编号
		ArrayList<Integer> pokerNumber = new ArrayList<Integer>();
		//定义出13个点数的数组
		String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
		//定义出4个花色的数组
		String[] colors = {"♠","♥","♣","♦"};
		//定义整数变量,作为键出现
		int index = 2;
		//遍历数组,花色+点数的组合,存储到Map集合
		for(String number : numbers){
			for(String color : colors){
				poker.put(index, color + number);
				pokerNumber.add(index);
				index++;
			}
		}
		System.out.println("看一下组合牌");
		System.out.println(poker);//无序集合
		System.out.println("========================================");
		System.out.println(pokerNumber);//牌的索引 也就是牌的编号
		System.out.println("========================================");
		//存储剩余两张牌
		poker.put(0, "大王");
		pokerNumber.add(0);
		poker.put(1, "小王");
		pokerNumber.add(1);
		
		//2.洗牌,将牌的编号打乱
		Collections.shuffle(pokerNumber);
		System.out.println(pokerNumber);//牌的索引 也就是牌的编号
		System.out.println("========================================");
		
		//3.发牌功能,将牌编号,发给玩家集合,底牌集合
		ArrayList<Integer> palyer1 = new ArrayList<Integer>();
		ArrayList<Integer> palyer2 = new ArrayList<Integer>();
		ArrayList<Integer> palyer3 = new ArrayList<Integer>();
		ArrayList<Integer> bottom = new ArrayList<Integer>();
		
		//发牌采用的是集合索引%3
		for(int i = 0; i < pokerNumber.size(); i++){
			//先将底牌做好
			if(i < 3){
				//存储到底牌去
			    // boolean add(E e) 
		        // 将指定的元素添加到此列表的尾部 
				// E get(int index) 
			    // 返回此列表中指定位置上的元素 
				// pokerNumber集合容器,里面所有元素被shuffle打乱(牌的编号打乱)
				// 故放入add()--(添加元素)
				// pokerNumber.get(i)是获取i对应的位置上元素(这个时候元素对应就是牌的编号（已经打乱）)
				//add(pokerNumber.get(i)) 这样就等于在发牌（实际是发牌的编号）
				bottom.add(pokerNumber.get(i));
			}else if(i % 3 == 0){
				//索引上的编号,给玩家1
				palyer1.add(pokerNumber.get(i));
			}else if(i % 3 == 1){
				//索引上的编号,给玩家2
				palyer2.add(pokerNumber.get(i));
			}else if(i % 3 == 2){
				//索引上的编号,给玩家3
				palyer3.add(pokerNumber.get(i));
			}
		}
		//对玩家手中的编号排序
		//static <T extends Comparable<? super T>> 
		//void sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序 
		//相当于把玩家手中牌从大到小排列号
		Collections.sort(palyer1);
		Collections.sort(palyer2);
		Collections.sort(palyer3);
		
		//看牌,将玩家手中的编号,到Map集合中查找,根据键找值
		//定义方法实现
		lookpoker("刘德华", palyer1, poker);
		lookpoker("周星驰", palyer2, poker);
		lookpoker("张曼玉", palyer3, poker);
		lookpoker("底牌", bottom, poker);
		
		
	}
	public static void lookpoker(String name,ArrayList<Integer> player,HashMap<Integer, String> poker){
		//遍历ArrayList集合,获取元素,作为键,到集合Map中找值
		System.out.print(name + " ");
		for(Integer key : player){
			String value = poker.get(key);
			System.out.print(value + " ");
		}
		System.out.println();
	}
}

输出结果：

看一下组合牌
{2=♠2, 3=♥2, 4=♣2, 5=♦2, 6=♠A, 7=♥A, 8=♣A, 9=♦A, 10=♠K, 11=♥K, 12=♣K, 13=♦K, 14=♠Q, 15=♥Q, 17=♦Q, 16=♣Q, 19=♥J, 18=♠J, 21=♦J, 20=♣J, 23=♥10, 22=♠10, 25=♦10, 24=♣10, 27=♥9, 26=♠9, 29=♦9, 28=♣9, 31=♥8, 30=♠8, 34=♠7, 35=♥7, 32=♣8, 33=♦8, 38=♠6, 39=♥6, 36=♣7, 37=♦7, 42=♠5, 43=♥5, 40=♣6, 41=♦6, 46=♠4, 47=♥4, 44=♣5, 45=♦5, 51=♥3, 50=♠3, 49=♦4, 48=♣4, 53=♦3, 52=♣3}
========================================
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53]
========================================
[20, 37, 42, 2, 50, 19, 43, 26, 51, 29, 27, 47, 0, 39, 36, 6, 32, 10, 38, 28, 25, 7, 5, 9, 23, 52, 30, 16, 35, 3, 31, 11, 12, 4, 46, 34, 48, 13, 22, 18, 24, 33, 15, 17, 41, 40, 45, 1, 8, 53, 44, 21, 14, 49]
========================================
刘德华 大王 ♠2 ♣2 ♠A ♥A ♣A ♥Q ♣Q ♠J ♦J ♥10 ♦9 ♥8 ♠6 ♣6 ♥5 ♣4 
周星驰 ♦2 ♥K ♦K ♠Q ♦Q ♣10 ♠9 ♥9 ♣9 ♣8 ♥7 ♥6 ♦5 ♠4 ♠3 ♣3 ♦3 
张曼玉 小王 ♥2 ♦A ♠K ♣K ♥J ♠10 ♦10 ♠8 ♦8 ♠7 ♣7 ♦6 ♣5 ♥4 ♦4 ♥3 
底牌 ♣J ♦7 ♠5