20_集合_第20天(Map可变参数Collections)_讲义

Posted wanghui1234

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了20_集合_第20天(Map可变参数Collections)_讲义相关的知识,希望对你有一定的参考价值。

今日内容介绍
1、Map接口
2、模拟斗地主洗牌发牌

01Map集合概述

A:Map集合概述:

我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储数据的形式不同
?   a:Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。
?   
    b:Map中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的值。
? 
    Collection中的集合称为单列集合,Map中的集合称为双列集合。
?   需要注意的是,Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。
Map
 |--HashMap
 |--LinkedHashMap

02Map接口中的常用方法

A:Map接口中的常用方法

   /*
    *  Map接口中的常用方法
    *    使用Map接口的实现类 HashMap
    */
   public class MapDemo {
    public static void main(String[] args) {
        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(33);
        System.out.println(value);
        System.out.println(map);
    }
    
    /*
     * 通过键对象,获取值对象
     * V get(K)
     * 如果集合中没有这个键,返回null
     */
    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(4);
        System.out.println(value);
    }
    
    /*
     *  将键值对存储到集合中
     *  V put(K,V) K 作为键的对象, V作为值的对象
     *  存储的是重复的键,将原有的值,覆盖
     *  返回值一般情况下返回null,
     *  存储重复键的时候,返回被覆盖之前的值
     */
    public static void function(){
        //创建集合对象,HashMap,存储对象,键是字符串,值是整数
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 1);
        
        map.put("b", 2);
        
        map.put("c", 3);
        
        System.out.println(map);
    }
   }

03Map集合遍历方式keySet方法

A:Map集合遍历方式keySet方法

 1.获取Map集合中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键
 2.遍历键的Set集合,得到每一个键
 3.根据键利用get(key)去Map找所对应的值
 /*
  *  Map集合的遍历
  *    利用键获取值
  *    Map接口中定义方法keySet
  *    所有的键,存储到Set集合
  */
 public class MapDemo1 {
    public static void main(String[] args) {
        /*
         *  1. 调用map集合的方法keySet,所有的键存储到Set集合中
         *  2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
         *  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();
        //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);
        }
        
        System.out.println("=======================");
        

        for(String key : map.keySet()){
            Integer value = map.get(key);
            System.out.println(key+"...."+value);
        }
    }
 }

04Map集合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集合形式返回。

05Map集合遍历方式entrySet方法

A:Map集合遍历方式entrySet方法

*
 *  Map集合获取方式
 *  entrySet方法,键值对映射关系(结婚证)获取
 *  实现步骤:
 *    1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
 *        Set<Entry <K,V> >
 *    2. 迭代Set集合
 *    3. 获取出的Set集合的元素,是映射关系对象
 *    4. 通过映射关系对象方法 getKet, getValue获取键值对
 *    
 *    创建内部类对象 外部类.内部类 = new 
 */
public class MapDemo2 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "abc");
        map.put(2, "bcd");
        map.put(3, "cde");
        //1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
        Set<Map.Entry <Integer,String> >  set = map.entrySet();
        //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. 通过映射关系对象方法 getKet, getValue获取键值对
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"...."+value);
        }
        
         
    }
}

06Map集合遍历方式增强for循环

A:Map集合遍历方式增强for循环

 A:Map集合遍历方式entrySet方法
  *
   *  Map集合获取方式
   *  entrySet方法,键值对映射关系(结婚证)获取
   *  实现步骤:
   *    1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
   *        Set<Entry <K,V> >
   *    2. 迭代Set集合
   *    3. 获取出的Set集合的元素,是映射关系对象
   *    4. 通过映射关系对象方法 getKet, getValue获取键值对
   *    
   *    创建内部类对象 外部类.内部类 = new 
   */
  public class MapDemo2 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "abc");
        map.put(2, "bcd");
        map.put(3, "cde");
        //1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
        Set<Map.Entry <Integer,String> >  set = map.entrySet();
        //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. 通过映射关系对象方法 getKet, getValue获取键值对
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"...."+value);
        }
        
        System.out.println("=========================");
        for(Map.Entry<Integer, String> entry : map.entrySet()){
            System.out.println(entry.getKey()+"..."+entry.getValue());
        }
    }
  }
  
  注意:Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

07HashMap集合存储和遍历

A:HashMap集合存储和遍历

 /*
  *  使用HashMap集合,存储自定义的对象
  *  自定义对象,作为键,出现,作为值出现
  */
 public class HashMapDemo {
    public static void main(String[] args) {
        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), "里约热内卢");
        map.put(new Person("b",18), "索马里");
        map.put(new Person("b",18), "索马里");
        map.put(new Person("c",19), "百慕大");
        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",18));
        map.put("shanghai", new Person("c",19));
        for(String key : map.keySet()){
            Person value = map.get(key);
            System.out.println(key+"..."+value);
        }
        System.out.println("=================");
        for(Map.Entry<String, Person> entry : map.entrySet()){
            String key = entry.getKey();
            Person value = entry.getValue();
            System.out.println(key+"..."+value);
        }
    }
 }

08LinkedHashMap的特点

*A: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("13", "a");
        link.put("15", "a");
        link.put("17", "a");
        System.out.println(link);
    }
  }

09Hashtable的特点

*A:Hashtable的特点

   /*
    *  Map接口实现类 Hashtable
    *  底层数据结果哈希表,特点和HashMap是一样的
    *  Hashtable 线程安全集合,运行速度慢
    *  HashMap 线程不安全的集合,运行速度快
    *  
    *  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 Hashtable<String,String>();
        map.put(null, null);
        System.out.println(map);
    }
   }

10静态导入

*A:静态导入:如果本类中有和静态导入的同名方法会优先使用本类的

           如果还想使用静态导入的,依然需要类名来调用
   /*
    * 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) {
        out.println("hello");
        
        int[] arr = {1,4,2};
        sort(arr);
    }
   }

11方法的可变参数

*A:方法的可变参数

 /*
  *  JDK1.5新的特性,方法的可变参数
  *  前提: 方法参数数据类型确定,参数的个数任意
  *  可变参数语法: 数据类型...变量名
  *  可变参数,本质就是一个数组
  */
 public class VarArgumentsDemo {
    public static void main(String[] args) {
        //调用一个带有可变参数的方法,传递参数,可以任意
    //  getSum();
        int sum = getSum(5,34,3,56,7,8,0);
        System.out.println(sum);

    }
 
    /*
     * 定义方法,计算10个整数和
     * 方法的可变参数实现
     */
    public static int getSum(int...a){
        int sum = 0 ;
        for(int i : a){
            sum = 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;
    }*/
 }

12可变参数的注意事项

*A:可变参数的注意事项

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

13Collections工具类

A:Collections工具类

  /*
   *  集合操作的工具类
   *    Collections
   */
  public class CollectionsDemo {
    public static void main(String[] args) {
        function_2();
    }
    /*
     * Collections.shuffle方法
     * 对List集合中的元素,进行随机排列
     */
    public static void function_2(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(5);
        list.add(9);
        list.add(11);
        list.add(8);
        list.add(10);
        list.add(15);
        list.add(20);   
        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(5);
        list.add(8);
        list.add(10);
        list.add(15);
        list.add(20);
        //调用工具类静态方法binarySearch
        int index = Collections.binarySearch(list, 16);
        System.out.println(index);
    }
    
    /*
     *  Collections.sort静态方法
     *  对于List集合,进行升序排列
     */
    public static void function(){
        //创建List集合
        List<String> list = new ArrayList<String>();
        list.add("ewrew");
        list.add("qwesd");
        list.add("Qwesd");
        list.add("bv");
        list.add("wer");
        System.out.println(list);
        //调用集合工具类的方法sort
        Collections.sort(list);
        System.out.println(list);
    }
  }

14集合的嵌套

A:集合的嵌套

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

15集合的嵌套keySet遍历

A:集合的嵌套keySet遍历

   /*
    *  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);
         
    }
    
     
    
    public static void keySet(HashMap<String,HashMap<String,String>> czbk){
        //调用czbk集合方法keySet将键存储到Set集合
        Set<String> classNameSet = czbk.keySet();
        //迭代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> studentNum = classMap.keySet();
            Iterator<String> studentIt = studentNum.iterator();
       
               while(studentIt.hasNext()){
                //studentIt.next获取出来的是classMap的键,学号
                String numKey = studentIt.next();
                //调用classMap集合中的get方法获取值
                String nameValue = classMap.get(numKey);
                System.out.println(classNameKey+".."+numKey+".."+nameValue);
            }
        }
        
        System.out.println("==================================");
        for(String className: czbk.keySet()){
           HashMap<String, String> hashMap = czbk.get(className);   
           for(String numKey : hashMap.keySet()){
               String nameValue = hashMap.get(numKey);
               System.out.println(className+".."+numKey+".."+nameValue);
           }
        }
    }

   } 
  

16集合的嵌套entrySet遍历

A:集合的嵌套entrySet遍历

/*
 *  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);
        
        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();
            //获取值,值是一个Map集合
            HashMap<String,String> classMap = classNameEntry.getValue();
            //调用班级集合classMap方法entrySet,键值对关系对象存储Set集合
            Set<Map.Entry<String, String>> studentSet = classMap.entrySet();
            //迭代Set集合
            Iterator<Map.Entry<String, String>> studentIt = studentSet.iterator();
            while(studentIt.hasNext()){
                //studentIt方法next获取出的是班级集合的键值对关系对象
                Map.Entry<String, String> studentEntry = studentIt.next();
                //studentEntry方法 getKey getValue
                String numKey = studentEntry.getKey();
                String nameValue = studentEntry.getValue();
                System.out.println(classNameKey+".."+numKey+".."+nameValue);
            }
        }
         System.out.println("==================================");
        
        for (Map.Entry<String, HashMap<String, String>> me : czbk.entrySet()) {
            String classNameKey = me.getKey();
            HashMap<String, String> numNameMapValue = me.getValue();
            for (Map.Entry<String, String> nameMapEntry : numNameMapValue.entrySet()) {
                String numKey = nameMapEntry.getKey();
                String nameValue = nameMapEntry.getValue();
                System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
            }
        }
    }
    

}

17斗地主的功能分析

A:斗地主的功能分析

   a:具体规则:
        1. 组装54张扑克牌
        2. 将54张牌顺序打乱
        3. 三个玩家参与游戏,三人交替摸牌,每人17张牌,最后三张留作底牌。
        4. 查看三人各自手中的牌(按照牌的大小排序)、底牌
   b:分析:
      1.准备牌:
       完成数字与纸牌的映射关系:
       使用双列Map(HashMap)集合,完成一个数字与字符串纸牌的对应关系(相当于一个字典)。
      2.洗牌:
       通过数字完成洗牌发牌
      3.发牌:
       将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌,剩余牌通过对3取模依次发牌。
       存放的过程中要求数字大小与斗地主规则的大小对应。
       将代表不同纸牌的数字分配给不同的玩家与底牌。
      4.看牌:
       通过Map集合找到对应字符展示。
       通过查询纸牌与数字的对应关系,由数字转成纸牌字符串再进行展示。

18斗地主的准备牌

A:斗地主的准备牌

 /*
  *  实现模拟斗地主的功能
  *   1. 组合牌
  *   2. 洗牌
  *   3. 发牌
  *   4. 看牌
  */
 public class DouDiZhu {
    public static void main(String[] args) {
        //1. 组合牌
        //创建Map集合,键是编号,值是牌
        HashMap<Integer,String> pooker = new HashMap<Integer, String>();
        //创建List集合,存储编号
        ArrayList<Integer> pookerNumber = 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){
                pooker.put(index, color+number);
                pookerNumber.add(index);
                index++;
            }
        }
        //存储大王,和小王,索引是从0~54,对应大王,小王,...3(牌的顺序从大到小)
        pooker.put(0, "大王");
        pookerNumber.add(0);
        pooker.put(1, "小王");
        pookerNumber.add(1);
     
 }

19斗地主的洗牌

A:斗地主的洗牌

  /*
   *  实现模拟斗地主的功能
   *   1. 组合牌
   *   2. 洗牌
   *   3. 发牌
   *   4. 看牌
   */
  public class DouDiZhu {
    public static void main(String[] args) {
        //1. 组合牌
        //创建Map集合,键是编号,值是牌
        HashMap<Integer,String> pooker = new HashMap<Integer, String>();
        //创建List集合,存储编号
        ArrayList<Integer> pookerNumber = 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){
                pooker.put(index, color+number);
                pookerNumber.add(index);
                index++;
            }
        }
        //存储大王,和小王
        pooker.put(0, "大王");
        pookerNumber.add(0);
        pooker.put(1, "小王");
        pookerNumber.add(1);
        
        //洗牌,将牌的编号打乱
        Collections.shuffle(pookerNumber);
        
     
    }
     
  }

20斗地主的发牌

A:斗地主的发牌

/*
 *  实现模拟斗地主的功能
 *   1. 组合牌
 *   2. 洗牌
 *   3. 发牌
 *   4. 看牌
 */
public class DouDiZhu {
    public static void main(String[] args) {
        //1. 组合牌
        //创建Map集合,键是编号,值是牌
        HashMap<Integer,String> pooker = new HashMap<Integer, String>();
        //创建List集合,存储编号
        ArrayList<Integer> pookerNumber = 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){
                pooker.put(index, color+number);
                pookerNumber.add(index);
                index++;
            }
        }
        //存储大王,和小王
        pooker.put(0, "大王");
        pookerNumber.add(0);
        pooker.put(1, "小王");
        pookerNumber.add(1);
        
        //洗牌,将牌的编号打乱
        Collections.shuffle(pookerNumber);
        
        //发牌功能,将牌编号,发给玩家集合,底牌集合
        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 < pookerNumber.size() ; i++){
            //先将底牌做好
            if(i < 3){
                //存到底牌去
                bottom.add( pookerNumber.get(i));
               //对索引%3判断
            }else if(i % 3 == 0){
                //索引上的编号,发给玩家1
                player1.add( pookerNumber.get(i) );
            }else if( i % 3 == 1){
                //索引上的编号,发给玩家2
                player2.add( pookerNumber.get(i) );
            }else if( i % 3 == 2){
                //索引上的编号,发给玩家3
                player3.add( pookerNumber.get(i) );
            }
        }
         
    }
     
}

21斗地主的看牌

A:斗地主的看牌

 /*
  *  实现模拟斗地主的功能
  *   1. 组合牌
  *   2. 洗牌
  *   3. 发牌
  *   4. 看牌
  */
 public class DouDiZhu {
    public static void main(String[] args) {
        //1. 组合牌
        //创建Map集合,键是编号,值是牌
        HashMap<Integer,String> pooker = new HashMap<Integer, String>();
        //创建List集合,存储编号
        ArrayList<Integer> pookerNumber = 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){
                pooker.put(index, color+number);
                pookerNumber.add(index);
                index++;
            }
        }
        //存储大王,和小王
        pooker.put(0, "大王");
        pookerNumber.add(0);
        pooker.put(1, "小王");
        pookerNumber.add(1);
        
        //洗牌,将牌的编号打乱
        Collections.shuffle(pookerNumber);
        
        //发牌功能,将牌编号,发给玩家集合,底牌集合
        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 < pookerNumber.size() ; i++){
            //先将底牌做好
            if(i < 3){
                //存到底牌去
                bottom.add( pookerNumber.get(i));
               //对索引%3判断
            }else if(i % 3 == 0){
                //索引上的编号,发给玩家1
                player1.add( pookerNumber.get(i) );
            }else if( i % 3 == 1){
                //索引上的编号,发给玩家2
                player2.add( pookerNumber.get(i) );
            }else if( i % 3 == 2){
                //索引上的编号,发给玩家3
                player3.add( pookerNumber.get(i) );
            }
        }
        //对玩家手中的编号排序
        Collections.sort(player1);
        Collections.sort(player2);
        Collections.sort(player3);
        //看牌,将玩家手中的编号,到Map集合中查找,根据键找值
        //定义方法实现
        look("刘德华",player1,pooker);
        look("张曼玉",player2,pooker);
        look("林青霞",player3,pooker);
        look("底牌",bottom,pooker);
    }
    public static void look(String name,ArrayList<Integer> player,HashMap<Integer,String> pooker){
        //遍历ArrayList集合,获取元素,作为键,到集合Map中找值
        System.out.print(name+" ");
        for(Integer key : player){
            String value = pooker.get(key);
            System.out.print(value+" ");
        }
        System.out.println();
    }
 }

作业测试

1.分析以下需求,并用代码实现:

(1)定义一个学生类Student,包含属性:姓名(String name)、年龄(int age)
(2)定义Map集合,用Student对象作为key,用字符串(此表示表示学生的住址)作为value
(3)利用四种方式遍历Map集合中的内容,格式:key::value
     

2.分析以下需求,并用代码实现:

(1)利用键盘录入,输入一个字符串
(2)统计该字符串中各个字符的数量
(3)如:

    用户输入字符串"If~you-want~to~change-your_fate_I_think~you~must~come-to-the-dark-horse-to-learn-java"
    程序输出结果:-(9)I(2)_(3)a(7)c(2)d(1)e(6)f(2)g(1)h(4)i(1)j(1)k(2)l(1)m(2)n(4)o(8)r(4)s(2)t(8)u(4)v(1)w(1)y(3)~(6)

以上是关于20_集合_第20天(Map可变参数Collections)_讲义的主要内容,如果未能解决你的问题,请参考以下文章

java基础(20):Map可变参数Collections

第20课 可变参数模板_模板参数包和函数参数包

集合Map可变参数Collections

毕向东_Java基础视频教程第20天_IO流(11~14)

毕向东_Java基础视频教程第20天_IO流(1~4)

马哥教育第20天至23天学习总结