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

秒速五厘米 2022-04-15 01:41 206阅读 0赞

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);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]

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);
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]

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());
    		}
    		
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]

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());
    		}	
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]

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);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]

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);
    		
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]

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);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]

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;
        }*/
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]

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);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]

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);
    			}
    		}
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220415/3f9ba5caae7142c1a040f5a474e5c820.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220415/b977b85c5a4a4caf9b237f43acf04b56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220415/50762aa3b6f0433b96c90742fc124b86.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220415/32124bc8ec304c91b864abe7d8c71c34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220415/acc584f3cab145fdbd3bc265b44956e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220415/a0e36ad46aec4ceeaaecded39e45ac2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220415/eae665d813a149899efa8e4c4dc5b0ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220415/aa4a592e3e6a453b9a858f02d0b5ff0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220415/a810066a05e347f19bd6f5968128ba26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20220415/e2081b76b71e4a4aa67ca00ac13bc505.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]: /images/20220415/33963cffbb5144caa5aad33a44c981b8.png