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

今天药忘吃喽~ 2022-04-16 06:16 198阅读 0赞

今日内容介绍  
1、Map接口  
2、模拟斗地主洗牌发牌  
第20天 集合  
第1章 Map接口  
1.1 Map接口概述  
我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。  
 Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。  
 Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。  
 Collection中的集合称为单列集合，Map中的集合称为双列集合。  
 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。  
 Map中常用的集合为HashMap集合、LinkedHashMap集合。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]  
1.2 Map接口中常用集合概述  
通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。  
 HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。  
 LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。  
 注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。  
1.3 Map接口中的常用方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]  
 put方法：将指定的键与值对应起来，并添加到集合中  
 方法返回值为键所对应的值  
使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；  
使用put方法时，若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。  
 get方法：获取指定键(key)所对应的值(value)  
 remove方法：根据指定的键(key)删除元素，返回被删除元素的值(value)。  
Map接口的方法演示

package cn.itcast.demo01;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /*
     * Map接口中的常用方法
     * 	使用Map接口的实现类HashMap
     */
    public class MapDemo {
    	public static void main(String[] args) {
    		function();
    		System.out.println();
    		function_1();
    		System.out.println();
    		function_2();
    	}
    	/*
    	 * 移除集合中的键值对,返回被移除之前的值
    	 * V remove(k)
    	 */
    	public static void function_2(){
    		//创建集合对象,作为键的对象整数,值的对象存储到字符串
    		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);
    	}
    	/*
    	 * 通过键对象,获取值对象
    	 * V get(K)
    	 * 如果集合中没有该键,就返回空
    	 */
    	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);
    	}
    	/*
    	 * 将键值对存储到集合中
    	 * V put(K,V) 
    	 * K:键的对象 V:值的对象
    	 * 存储的是重复的键,将原来的值,覆盖,值可以重复,键不允许
    	 * 返回值一般情况下返回null
    	 * 存储重复键,返回被覆盖之前的值
    	 */
    	public static void function(){
    		//创建集合对象,HashMap,存储对象,键是字符串,值是整数
    		Map<String,Integer> map = new HashMap<String,Integer>();
    		
    		Integer i1 = map.put("a", 1);
    		//返回值一般情况下返回null
    		System.out.println(i1);
    		
    		Integer i2 = map.put("a", 2);
    		//存储重复键,返回被覆盖之前的值
    		System.out.println(i2);
    		
    		map.put("c", 3);
    		//存储的是重复的键,将原来的值,覆盖
    		map.put("c", 5);
    		System.out.println(map);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]  
1.4 Map集合遍历方式keySet方法  
A:Map集合遍历方式keySet方法

package cn.itcast.demo01;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /*
     * 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循环来遍历Key)
    		 * 3.调用map集合方法get,通过键获取到值
    		 */
    		Map<String,Integer> map = new HashMap<String,Integer>();
    		map.put("a", 11);
    		map.put("b", 12);
    		map.put("c", 13);
    		map.put("d", 14);
    		
    		//1.调用map集合的方法keySet,所有的键存储到Set集合中
    		Set<String> set = map.keySet();
    		//[d, b, c, a]
    		System.out.println(set);
    		//class java.util.HashMap$KeySet
    		System.out.println("============================");
    		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集合方法get,通过键获取到值
    			String key = it.next();
    			Integer value = map.get(key);
    			System.out.println(key + "..." + value);
    		}
    		//使用增强for循环来遍历Set集合,可发现增强for循环更加简洁
    		//但是其实增强for循环编译后就是迭代器
    		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 3]  
15 Map集合Entry对象  
A:Map集合Entry对象

interface Map{
        interface Entry{//Entry是Map的一个内部接口
                       //由Map的子类的内部类实现
    
        }
     }
     class HashMap{
        static class Entry<K,V> implements Map.Entry<K,V> {//Entry对象指的就是该类的对象
            final K key;
                  V value;
        }
     }
     在Map类设计时，提供了一个嵌套接口：Entry。
     Entry将键值对的对应关系封装成了对象。
     即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
       a:Entry是Map接口中提供的一个静态内部嵌套接口。
       b:相关方法
        getKey()方法：获取Entry对象中的键
       getValue()方法：获取Entry对象中的值
       entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]  
1.6 Map集合遍历方式entrySet方法  
A:Map集合遍历方式entrySet方法  
B:Map集合遍历方式增强for循环

package cn.itcast.demo01;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /*
     * 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(1, "abc");
    		map.put(2, "bcd");
    		map.put(3, "cde");
    		//1.调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
    		Set<Map.Entry<Integer, String>> set = map.entrySet();
    		//class java.util.HashMap$EntrySet
    		//getClass()（Object类的方法,意味着每个子类都有这个方法）返回这个类的全名
    		System.out.println(set.getClass());
    		System.out.println("============================");
    		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()获取键值对
    			Integer key = entry.getKey();
    			String value = entry.getValue();
    			System.out.println(key + "..." + value);
    		}	
    		
    		System.out.println("============================");
    		//增强for循环,Iterable接口下所有实现类都能遍历,而Iterable下面子类没有Map
    		//我们增强for循环是遍历set,不能遍历Map集合
    		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 5]  
1.7 HashMap存储自定义类型键值  
练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。  
注意，学生姓名相同并且年龄相同视为同一名学生。  
** 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。  
 如果要保证map中存放的key和取出的顺序一致，可以使用LinkedHashMap集合来存放。**

package cn.itcast.demo02;
    
    public class Person {
    	private String name;
    	private int age;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	//空参构造函数
    	public Person() {
    		super();
    		
    	}	
    	public Person(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "Person" + "..." + name + "..." + age;
    	}
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + age;
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		return result;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (age != other.age)
    			return false;
    		if (name == null) {
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		return true;
    	}
    }

package cn.itcast.demo02;
    
    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,作为键出现
    	 * 键的对象,是Person类型,值是字符串
    	 * 保证键的唯一性,存储到键的对象,需要重写hashCode 和 equals方法
    	 */
    	public static void function_1(){
    		HashMap<Person, String> map = new HashMap<Person,String>();
    		map.put(new Person("a",20), "上海");
    		//保证键的唯一性,存储到键的对象,需要重写hashCode 和 equals方法
    		map.put(new Person("b",10), "天津");
    		map.put(new Person("b",10), "天津");
    		map.put(new Person("c",30), "杭州");
    		for(Person key : map.keySet()){
    			String value = map.get(key);
    			System.out.println(key + "..." + value);
    		}
    		System.out.println("============================");
    		for(Map.Entry<Person, String> entry : map.entrySet()){
    			System.out.println(entry.getKey() + "..." + entry.getValue());
    		}
    		
    	}
    	/*
    	 * HashMap,存储自定义对象Person,作为值出现
    	 * 键的对象,是字符串,可以保证唯一性
    	 */
    	public static void function(){
    		HashMap<String,Person> map = new HashMap<String,Person>();
    		map.put("beijing", new Person("a",20));
    		map.put("tianjin", new Person("b",10));
    		map.put("shanghai", new Person("c",30));
    		//1.调用map集合的方法keySet,所有的键存储到Set集合中
    		//2.遍历Set集合,获取Set集合中所有的元素(Map中的键) (可以用迭代器或者增强for循环来遍历Key)
    		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(Map.Entry<String, Person> entry : map.entrySet()){
    			//4.通过映射关系对象方法getKey(),getValue()获取键值对
    			String key = entry.getKey();
    			Person value = entry.getValue();
    			System.out.println(key + "..." + value);
    		}
    	}
    	
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]  
1.8 静态导入  
在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。  
**静态导入格式：**  
**import static XXX.YYY; 导入后YYY可直接使用。**  
例如：Map.Entry的访问，简化后为Entry

import static java.util.Map.Entry;
    public class HashMapTest {
    	public static void main(String[] args) {
    		//1,创建hashmap集合对象。
    		Map<Student,String> map = new HashMap<Student,String>();
    
    		//取出元素。键值对方式
    		//Set<Map.Entry<Student, String>> entrySet = map.entrySet();
    		Set<Entry<Student, String>> entrySet = map.entrySet();
    
    		//for (Map.Entry<Student, String> entry : entrySet) {
    		for (Entry<Student, String> entry : entrySet) {
    			Student key = entry.getKey();
    			String value = entry.getValue();
    			System.out.println(key.toString()+"....."+value);
    		}
    	}
    }

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 7]  
1.9 LinkedHashMap的特点  
\*A:LinkedHashMap的特点

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 8]  
1.10 Hashtable的特点  
\*A:Hashtable的特点

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 9]  
1.11 可变参数  
在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：  
**修饰符 返回值类型 方法名(参数类型… 形参名)\{ \}**  
其实这个书写完全等价与  
**修饰符 返回值类型 方法名(参数类型\[\] 形参名)\{ \}**  
只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

jdk1.5以后。出现了简化操作。… 用在参数上，称之为可变参数。  
同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。  
** 上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性  
注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。**

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 10]  
1.12可变参数的注意事项  
\*A:可变参数的注意事项

/*
        * 可变参数的注意事项
        * 1. 一个方法中,可变参数只能有一个
        * 2. 可变参数,必须写在参数列表的最后一位
        */
        public static void function(Object...o){
         
        }

1.13 Collections集合工具类  
Collections是集合工具类，用来对集合进行操作。部分方法如下：  
![在这里插入图片描述][20181118161639338.png]  
 public static void sort(List list) // 集合元素排序

//排序前元素list集合元素 [33,11,77,55]
    Collections.sort( list );
    //排序后元素list集合元素 [11,33,55,77]

 public static void shuffle(List<?> list) // 集合元素存储位置打乱

//list集合元素 [11,33,55,77]
    Collections.shuffle( list );
    //使用shuffle方法后，集合中的元素为[77,33,11,55]，每次执行该方法，集合中存储的元素位置都会随机打乱

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 11]  
1.14 集合嵌套  
集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。  
 ArrayList嵌套 ArrayList

ArrayList< ArrayList<String> >
    	Collection< ArrayList<Integer> >

 Map嵌套 ArrayList

HashMap<String, ArrayList<Person>>
    ArrayList< HashMap<String, String>>

 Map集合嵌套

HashMap<String, HashMap<String,String>>
    HashMap<String, HashMap<Person,String>>

package cn.itcast.demo05;
    
    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("基础班", javase);
    		czbk.put("就业班", javaee);	
    		
    		keySet(czbk);
    		System.out.println("=================================");
    		entrySet(czbk);
    	}
    	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集合容器
    			Set<Map.Entry<String, String>> studentNameSet = classMap.entrySet();
    			//迭代器迭代Set集合容器(其中泛型不要自己写,根据上面直接复制或者根据提示)
    			Iterator<Map.Entry<String, String>> studentNameIt = studentNameSet.iterator();
    			while(studentNameIt.hasNext()){
    				//studentNameIt.next()获取的是classMap集合容器的键值对关系对象
    				Map.Entry<String, String> studentNameEntry = studentNameIt.next();
    				//studentNameEntry方法getKey()以及getValue()获取键值对
    				String studentID = studentNameEntry.getKey();
    				//获取值,值是String
    				String studentName = studentNameEntry.getValue();
    				System.out.println(classNameKey + "..." + studentID + "..." + studentName);
    			}
    			
    		}
    	}
    	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集合,进行遍历
    			Set<String> studentIno = classMap.keySet();
    			//studentIno是一个Set集合容器,String - String 
    			//studentIno:[001, 002]
    			//System.out.println("studentIno:" + studentIno);
    			//迭代基础班集合容器/就业班集合   Set集合容器
    			Iterator<String> studentIt = studentIno.iterator();
    			while(studentIt.hasNext()){
    				//studentIt.next()获取出来的是classMap的键,也就是学生学号
    				String studentID = studentIt.next();
    				//调用classMap集合中的get方法获取值
    				String studentName = classMap.get(studentID);
    				System.out.println(classNameKey + "..." + studentID + "..." + studentName);
    			}		
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]  
1.15 集合继承体系的面向对象思想  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]  
 接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；  
 抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；  
 具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。  
第2章 模拟斗地主洗牌发牌  
2.1 案例介绍  
按照斗地主的规则，完成洗牌发牌的动作。  
![在这里插入图片描述][20181118162705625.png]  
具体规则：  
1. 组装54张扑克牌  
2. 将54张牌顺序打乱  
3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。  
4. 查看三人各自手中的牌（按照牌的大小排序）、底牌  
 手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3  
2.2 案例需求分析  
 准备牌：  
完成数字与纸牌的映射关系：  
使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。  
 洗牌：  
通过数字完成洗牌发牌  
 发牌：  
将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。  
存放的过程中要求数字大小与斗地主规则的大小对应。  
将代表不同纸牌的数字分配给不同的玩家与底牌。  
 看牌：  
通过Map集合找到对应字符展示。  
通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]  
2.3 实现代码步骤  
首先，要修改java文件编码，**由GBK修改为UTF-8**，因为默认的字符编码GBK没有我们要的梅花、方片、黑桃、红桃(♠♥♦♣)等特殊字符。

package cn.itcast.demo06;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.HashMap;
    
    /*
     * 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(pokerNumber);
    		System.out.println("======================================");
    		//存储大王和小王
    		poker.put(0, "大王");
    		pokerNumber.add(0);
    		poker.put(1, "小王");
    		pokerNumber.add(1);
    		
    		//2.洗牌,将牌的编号打乱
    		Collections.shuffle(pokerNumber);
    		
    		//3.发牌功能,将牌编号,发给玩家集合,底牌集合
    		ArrayList<Integer> player1 = new ArrayList<Integer>();
    		ArrayList<Integer> player2 = new ArrayList<Integer>();
    		ArrayList<Integer> player3 = new ArrayList<Integer>();
    		ArrayList<Integer> bottom = new ArrayList<Integer>();
    		
    		//发牌采用的是集合索引%3
    		for(int i =  0; i < pokerNumber.size(); i++){
    			//先将底牌做好
    			if(i < 3){
    				//存储到底牌去
    				bottom.add(pokerNumber.get(i));
    			}else if(i % 3 == 0){//对索引%3
    				//索引上的编号,发给玩家1
    				player1.add(pokerNumber.get(i));
    			}else if(i % 3 == 1){
    				//索引上的编号,发给玩家2
    				player2.add(pokerNumber.get(i));
    			}else if(i % 3 == 2){
    				//索引上的编号,发给玩家3
    				player3.add(pokerNumber.get(i));
    			}
    		}
    		//对玩家手中的编号排序
    		Collections.sort(player1);
    		Collections.sort(player2);
    		Collections.sort(player3);
    		
    		//看牌,将玩家手中的编号,到Map集合中查找,根据键找值
    		//定义方法实现
    		lookpoker("刘德华", player1, poker);
    		lookpoker("周星驰", player2, poker);
    		lookpoker("张曼玉", player3, 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]
    ======================================
    刘德华  大王 小王 ♦A ♥K ♦Q ♠10 ♥10 ♠8 ♥8 ♣7 ♦7 ♠6 ♦5 ♣4 ♦4 ♥3 ♦3 
    周星驰  ♥2 ♦2 ♠A ♥A ♣K ♦K ♣J ♦J ♣10 ♦10 ♦8 ♥7 ♣6 ♠5 ♥5 ♠4 ♣3 
    张曼玉  ♠2 ♣2 ♠K ♠Q ♥Q ♣Q ♠J ♠9 ♥9 ♣9 ♦9 ♣8 ♠7 ♥6 ♣5 ♥4 ♠3 
    底牌  ♣A ♥J ♦6

第3章 总结  
3.1 知识点总结  
 Map集合:  
map集合中的元素都是成对出现，成对存储的  
map集合中的元素都是以一对键和值的形式组成存在的，称为键值对，理解为夫妻对  
map集合中的键不能重复存储，值可以重复  
map集合中的每一个键 对应着一个值  
 方法：  
V put(K key, V value) 把指定的键与指定的值添加到Map集合中  
V remove(Object key) 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值  
Set<Map.Entry<K,V>> entrySet() 获取到Map集合中所有的键值对对象的集合(Set集合)  
V get(Object key) 根据指定的键，在Map集合中获取对应的值  
Set keySet() 获取Map集合中所有的键，存储到Set集合中

 Map集合遍历的两种方式  
 方式1：根据键找值的方式

//a, 获取到Map集合中所有的键，返回对应的Set集合
    		//b, 遍历键的集合，获取到每一个键
    		//c, 通过键，找到对应的值
    		
    		//获取到Map集合中所有的键，返回对应的Set集合
    		Set<String> keys = map.keySet();
    		//遍历键的集合，获取到每一个键
    		for (String key : keys) {
    			//通过键，找到对应的值
    			Student s = map.get(key);
    			System.out.println( key + "..." + s.getName() + "..." + s.getAge() );
    		}

 方式2：根据键值对对象找键和值的方式

//a, 获取Map集合中所有的键值对元素,返回对应的Set集合
    		//b, 遍历键值对元素集合，获取到每一个键值对元素对象
    		//c, 通过键值对元素对象，获取对应的键，和对应的值
    		
    		//获取Map集合中所有的键值对元素,返回对应的Set集合
    		Set< Map.Entry<String, Student>> entrySet = map.entrySet();
    		//遍历键值对元素集合，获取到每一个键值对元素对象
    		for (Map.Entry<String, Student> entry : entrySet) {
    			//通过键值对元素对象，获取对应的键，和对应的值
    			//找键
    			String key = entry.getKey();
    			//找值
    			Student s = entry.getValue();
    			//打印
    			System.out.println( key+"..."+s.getName()+"..."+s.getAge() );
    		}

 HashMap:  
 特点：  
是Map集合的子集合  
底层采用哈希表结构  
HashMap集合中的key不能重复，通过重写hashCode() 与 equals()方法来保证键的唯一。  
不能保证元素存与取的顺序完全一致  
 LinkedHashMap:  
 特点：  
是HashMap集合的子集合  
底层采用哈希表+链表结构  
LinkedHashMap集合中的key不能重复，通过重写hashCode() 与 equals()方法来保证键的唯一。

 Collections中的方法：  
public static void sort(List list) 排序  
public static void shuffle(List<?> list) 集合中的元素存储位置随机打乱

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220416/1676e5858ab14a9f8c484ba6f919f9bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220416/150c13ea2a7344aa99fcec0a553be085.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220416/e82d37204bf140448328a8d5ea96cd26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220416/66632517f6c34bf7868958b1a9d58bd2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220416/553794f429d549058777473ece13a3db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220416/fd60204427a84b8d816f81cd90d3cff2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220416/a79775298c974cc5b4bf56faf79d181d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220416/b50dfe6e038d492e8646fd1f2cd99e79.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220416/12d7c464e8a14072a92340bab31ac74a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20220416/614c731dc6454cea9fffffa01696590b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]: /images/20220416/d4f480e4b89b427b847b7b2cd09ecd59.png
[20181118161639338.png]: /images/20220416/39a26199ec3e4e1393f8101f0a6e0b01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]: /images/20220416/4687946665254d0a9e458cea151b7bd6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]: /images/20220416/1f4b435361ab4c3487d61f733261816f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]: /images/20220416/d9a7a36cd3564d99875f7f970204b4c5.png
[20181118162705625.png]: /images/20220416/bb6add2d6ef04b43ab22fc23af295af7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]: /images/20220416/192f7f6e1a3d48f48ef2220bf33eef95.png