01Map集合概述

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

02Map接口中的常用方法

  1. 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);
  2.  
  3.         String value = map.remove(33);
  4.         System.out.println(value);
  5.         System.out.println(map);
  6.     }
     
  7.     /*
  8.      * 通过键对象,获取值对象
  9.      * V get(K)
  10.      * 如果集合中没有这个键,返回null
  11.      */
  12.     public static void function_1(){
  13.         //创建集合对象,作为键的对象整数,值的对象存储字符串
  14.         Map<Integer,String> map = new HashMap<Integer, String>();
  15.         map.put(1, "a");
  16.         map.put(2, "b");
  17.         map.put(3, "c");
  18.         System.out.println(map);
  19.  
  20.         String value = map.get(4);
  21.         System.out.println(value);
  22.     }
  23.  
  24.     /*
  25.      *  将键值对存储到集合中
  26.      *  V put(K,V) K 作为键的对象, V作为值的对象
  27.      *  存储的是重复的键,将原有的值,覆盖
  28.      *  返回值一般情况下返回null,
  29.      *  存储重复键的时候,返回被覆盖之前的值
  30.      */
  31.     public static void function(){
  32.         //创建集合对象,HashMap,存储对象,键是字符串,值是整数
  33.         Map<String, Integer> map = new HashMap<String, Integer>();
  34.         map.put("a", 1);
  35.  
  36.         map.put("b", 2);
  37.  
  38.         map.put("c", 3);
  39.  
  40.         System.out.println(map);
  41.     }
  42.    }

03Map集合遍历方式keySet方法

  1. A:Map集合遍历方式keySet方法 
    1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键 
    2.遍历键的Set集合，得到每一个键 
    3.根据键利用get(key)去Map找所对应的值 
  2.  
  3. /* * 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);
  4.  
  5.         //1. 调用map集合的方法keySet,所有的键存储到Set集合中
  6.         Set<String> set = map.keySet();
  7.         //2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
  8.         Iterator<String> it = set.iterator();
  9.         while(it.hasNext()){
  10.             //it.next返回是Set集合元素,也就是Map中的键
  11.             //3. 调用map集合方法get,通过键获取到值
  12.             String key = it.next();
  13.             Integer value = map.get(key);
  14.             System.out.println(key+"...."+value);
  15.         }
  16.         System.out.println("=======================");
  17.  
  18.         for(String key : map.keySet()){
  19.             Integer value = map.get(key);
  20.             System.out.println(key+"...."+value);
  21.         }
  22.     }
  23.  }

04Map集合Entry对象

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

05Map集合遍历方式entrySet方法

  1.    A:Map集合遍历方式entrySet方法
  2.     *
  3.     *  Map集合获取方式
  4.     *  entrySet方法,键值对映射关系(结婚证)获取
  5.     *  实现步骤:
  6.     *    1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
  7.     *        Set<Entry <K,V> >
  8.     *    2. 迭代Set集合
  9.     *    3. 获取出的Set集合的元素,是映射关系对象
  10.     *    4. 通过映射关系对象方法 getKet, getValue获取键值对
  11.     *
  12.     *    创建内部类对象 外部类.内部类 = new
  13.     */
  14.  
  15.     public class MapDemo2 {
  16.  
  17.         public static void main(String[] args) {
  18.             Map<Integer,String> map = new HashMap<Integer, String>();
  19.             map.put(1, "abc");
  20.             map.put(2, "bcd");
  21.             map.put(3, "cde");
  22.             //1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
  23.             Set<Map.Entry <Integer,String> >  set = map.entrySet();
  24.             //2. 迭代Set集合
  25.             Iterator<Map.Entry <Integer,String> > it = set.iterator();
  26.             while(it.hasNext()){
  27.                 //  3. 获取出的Set集合的元素,是映射关系对象
  28.                 // it.next 获取的是什么对象,也是Map.Entry对象
  29.                 Map.Entry<Integer, String> entry = it.next();
  30.                 //4. 通过映射关系对象方法 getKet, getValue获取键值对
  31.                 Integer key = entry.getKey();
  32.                 String value = entry.getValue();
  33.                 System.out.println(key+"...."+value);
  34.             }

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

  1. 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); }
  2.         System.out.println("=========================");
  3.         for(Map.Entry<Integer, String> entry : map.entrySet()){
  4.             System.out.println(entry.getKey()+"..."+entry.getValue());
  5.         }
  6.     }
  7.   }
  8.  
  9.   注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

07HashMap集合存储和遍历

  1. A:HashMap集合存储和遍历 
  2.  
  3. /* 
    * 使用HashMap集合,存储自定义的对象 
    * 自定义对象,作为键,出现,作为值出现 
    */ 
    public class HashMapDemo { 
    public static void main(String[] args) { 
    function_1(); } 
  4.  
  5. /* 
    * 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), "百慕大"); 
  6.  
  7. 　　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()); 
    }
    }
  8.  
  9.     /*
  10.      * HashMap 存储自定义的对象Person,作为值出现
  11.      * 键的对象,是字符串,可以保证唯一性
  12.      */
  13.     public static void function(){
  14.         HashMap<String, Person> map = new HashMap<String, Person>();
  15.         map.put("beijing", new Person("a",20));
  16.         map.put("tianjin", new Person("b",18));
  17.         map.put("shanghai", new Person("c",19));
  18.         for(String key : map.keySet()){
  19.             Person value = map.get(key);
  20.             System.out.println(key+"..."+value);
  21.         }
  22.         System.out.println("=================");
  23.         for(Map.Entry<String, Person> entry : map.entrySet()){
  24.             String key = entry.getKey();
  25.             Person value = entry.getValue();
  26.             System.out.println(key+"..."+value);
  27.         }
  28.     }
  29.  }

08LinkedHashMap的特点

  1. *A:LinkedHashMap的特点
  2.   /*
  3.    *  LinkedHashMap继承HashMap
  4.    *  保证迭代的顺序
  5.    */
  6.   public class LinkedHashMapDemo {
  7.     public static void main(String[] args) {
  8.         LinkedHashMap<String, String> link = new LinkedHashMap<String, String>();
  9.         link.put("1", "a");
  10.         link.put("13", "a");
  11.         link.put("15", "a");
  12.         link.put("17", "a");
  13.         System.out.println(link);
  14.     }
  15.   }

09Hashtable的特点

  1. *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静态导入

  1. *A:静态导入:如果本类中有和静态导入的同名方法会优先使用本类的 如果还想使用静态导入的,依然需要类名来调用 
  2.  
  3. /* 
    * JDK1.5新特性,静态导入 * 减少开发的代码量 
    * 标准的写法,导入包的时候才能使用 
    * 
    * import static java.lang.System.out;最末尾,必须是一个静态成员 
    */ 
    import static java.lang.System.out; 
    import static java.util.Arrays.sort;
  4.  
  5.    public class StaticImportDemo {
  6.     public static void main(String[] args) {
  7.         out.println("hello");
  8.  
  9.         int[] arr = {1,4,2};
  10.         sort(arr);
  11.     }
  12.    }

11方法的可变参数

  1. *A:方法的可变参数 
    /* 
    * JDK1.5新的特性,方法的可变参数 
    * 前提: 方法参数数据类型确定,参数的个数任意 
    * 可变参数语法: 数据类型...变量名 
    * 可变参数,本质就是一个数组 
    */ 
  2.  
  3. public class VarArgumentsDemo { 
  4.  
  5. public static void main(String[] args) { 
  6.  
  7. 　　//调用一个带有可变参数的方法,传递参数,可以任意 
    　　// getSum(); 
    　　int sum = getSum(5,34,3,56,7,8,0); 
    　　System.out.println(sum);
  8.     }
  9.  
  10.     /*
  11.      * 定义方法,计算10个整数和
  12.      * 方法的可变参数实现
  13.      */
  14.     public static int getSum(int...a){
  15.         int sum = 0 ;
  16.         for(int i : a){
  17.             sum = sum + i;
  18.         }
  19.         return sum;
  20.     }
  21.  
  22.     /*
  23.      * 定义方法,计算3个整数和
  24.      */
  25.     /*public static int getSum(int a,int b ,int c){
  26.         return a+b+c;
  27.     }*/
  28.  
  29.     /*
  30.      * 定义方法,计算2个整数和
  31.      */
  32.     /*public static int getSum(int a,int b){
  33.         return a+b;
  34.     }*/
  35.  }

12可变参数的注意事项

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

13Collections工具类

  1. A:Collections工具类 
    /* 
    * 集合操作的工具类 
    * Collections 
    */ 
    public class CollectionsDemo { 
    public static void main(String[] args) { 
    function_2(); 
    } 
    /* 
    * Collections.shuffle方法 
    * 对List集合中的元素,进行随机排列 
  2.  
  3. */ 
    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);
  4.     //调用工具类方法shuffle对集合随机排列
  5.      Collections.shuffle(list);
  6.      System.out.println(list);
  7.     }
  8.  
  9.     /*
  10.      * Collections.binarySearch静态方法
  11.      * 对List集合进行二分搜索,方法参数,传递List集合,传递被查找的元素
  12.      */
  13.     public static void function_1(){
  14.         List<Integer> list = new ArrayList<Integer>();
  15.         list.add(1);
  16.         list.add(5);
  17.         list.add(8);
  18.         list.add(10);
  19.         list.add(15);
  20.         list.add(20);
  21.         //调用工具类静态方法binarySearch
  22.         int index = Collections.binarySearch(list, 16);
  23.         System.out.println(index);
  24.     }
  25.  
  26.     /*
  27.      *  Collections.sort静态方法
  28.      *  对于List集合,进行升序排列
  29.      */
  30.     public static void function(){
  31.         //创建List集合
  32.         List<String> list = new ArrayList<String>();
  33.         list.add("ewrew");
  34.         list.add("qwesd");
  35.         list.add("Qwesd");
  36.         list.add("bv");
  37.         list.add("wer");
  38.         System.out.println(list);
  39.         //调用集合工具类的方法sort
  40.         Collections.sort(list);
  41.         System.out.println(list);
  42.     }
  43.   }

14集合的嵌套

  1. A:集合的嵌套 
  2.  
  3. /* 
    * 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", "李四");
  4.    javaee.put("001", "王五");
  5.    javaee.put("002", "赵六");
  6.         //定义传智播客集合容器,键是班级名字,值是两个班级容器
  7.     HashMap<String, HashMap<String,String>> czbk =
  8.     new HashMap<String, HashMap<String,String>>();
  9.     czbk.put("基础班", javase);
  10.     czbk.put("就业班", javaee);
  11.     keySet(czbk);
  12.  
  13.     }

15集合的嵌套keySet遍历

  1. 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", "李四");
  2.  
  3.         javaee.put("001", "王五");
  4.         javaee.put("002", "赵六");
  5.         //定义传智播客集合容器,键是班级名字,值是两个班级容器
  6.         HashMap<String, HashMap<String,String>> czbk =
  7.                 new HashMap<String, HashMap<String,String>>();
  8.         czbk.put("基础班", javase);
  9.         czbk.put("就业班", javaee);
  10.         keySet(czbk);
  11.  
  12.     }
  13.  
  14.     public static void keySet(HashMap<String,HashMap<String,String>> czbk){
  15.         //调用czbk集合方法keySet将键存储到Set集合
  16.         Set<String> classNameSet = czbk.keySet();
  17.         //迭代Set集合
  18.         Iterator<String> classNameIt = classNameSet.iterator();
  19.         while(classNameIt.hasNext()){
  20.             //classNameIt.next获取出来的是Set集合元素,czbk集合的键
  21.             String classNameKey = classNameIt.next();
  22.             //czbk集合的方法get获取值,值是一个HashMap集合
  23.             HashMap<String,String> classMap = czbk.get(classNameKey);
  24.             //调用classMap集合方法keySet,键存储到Set集合
  25.             Set<String> studentNum = classMap.keySet();
  26.             Iterator<String> studentIt = studentNum.iterator();
  27.  
  28.                while(studentIt.hasNext()){
  29.                 //studentIt.next获取出来的是classMap的键,学号
  30.                 String numKey = studentIt.next();
  31.                 //调用classMap集合中的get方法获取值
  32.                 String nameValue = classMap.get(numKey);
  33.                 System.out.println(classNameKey+".."+numKey+".."+nameValue);
  34.             }
  35.         }
  36.  
  37.         System.out.println("==================================");
  38.         for(String className: czbk.keySet()){
  39.            HashMap<String, String> hashMap = czbk.get(className);
  40.            for(String numKey : hashMap.keySet()){
  41.                String nameValue = hashMap.get(numKey);
  42.                System.out.println(className+".."+numKey+".."+nameValue);
  43.            }
  44.         }
  45.     }
  46. ​
  47.    }

16集合的嵌套entrySet遍历

  1. A:集合的嵌套entrySet遍历
  2. /*
  3.  *  Map集合的嵌套,Map中存储的还是Map集合
  4.  *  要求:
  5.  *    传智播客
  6.  *      Java基础班
  7.  *        001  张三
  8.  *        002  李四
  9.  *
  10.  *      Java就业班
  11.  *        001  王五
  12.  *        002  赵六
  13.  *  对以上数据进行对象的存储
  14.  *   001 张三  键值对
  15.  *   Java基础班: 存储学号和姓名的键值对
  16.  *   Java就业班:
  17.  *   传智播客: 存储的是班级
  18.  *
  19.  *   基础班Map   <学号,姓名>
  20.  *   传智播客Map  <班级名字, 基础班Map>
  21.  */
  22. public class MapMapDemo {
  23.     public static void main(String[] args) {
  24.         //定义基础班集合
  25.         HashMap<String, String> javase = new HashMap<String, String>();
  26.         //定义就业班集合
  27.         HashMap<String, String> javaee = new HashMap<String, String>();
  28.         //向班级集合中,存储学生信息
  29.         javase.put("001", "张三");
  30.         javase.put("002", "李四");
  31.  
  32.         javaee.put("001", "王五");
  33.         javaee.put("002", "赵六");
  34.         //定义传智播客集合容器,键是班级名字,值是两个班级容器
  35.         HashMap<String, HashMap<String,String>> czbk =
  36.                 new HashMap<String, HashMap<String,String>>();
  37.         czbk.put("基础班", javase);
  38.         czbk.put("就业班", javaee);
  39.  
  40.         entrySet(czbk);
  41.     }
  42.  
  43.     public static void entrySet(HashMap<String,HashMap<String,String>> czbk){
  44.         //调用czbk集合方法entrySet方法,将czbk集合的键值对关系对象,存储到Set集合
  45.         Set<Map.Entry<String, HashMap<String,String>>>
  46.                                  classNameSet = czbk.entrySet();
  47.         //迭代器迭代Set集合
  48.         Iterator<Map.Entry<String, HashMap<String,String>>> classNameIt = classNameSet.iterator();
  49.         while(classNameIt.hasNext()){
  50.             //classNameIt.next方法,取出的是czbk集合的键值对关系对象
  51.             Map.Entry<String, HashMap<String,String>> classNameEntry =  classNameIt.next();
  52.             //classNameEntry方法 getKey,getValue
  53.             String classNameKey = classNameEntry.getKey();
  54.             //获取值,值是一个Map集合
  55.             HashMap<String,String> classMap = classNameEntry.getValue();
  56.             //调用班级集合classMap方法entrySet,键值对关系对象存储Set集合
  57.             Set<Map.Entry<String, String>> studentSet = classMap.entrySet();
  58.             //迭代Set集合
  59.             Iterator<Map.Entry<String, String>> studentIt = studentSet.iterator();
  60.             while(studentIt.hasNext()){
  61.                 //studentIt方法next获取出的是班级集合的键值对关系对象
  62.                 Map.Entry<String, String> studentEntry = studentIt.next();
  63.                 //studentEntry方法 getKey getValue
  64.                 String numKey = studentEntry.getKey();
  65.                 String nameValue = studentEntry.getValue();
  66.                 System.out.println(classNameKey+".."+numKey+".."+nameValue);
  67.             }
  68.         }
  69.          System.out.println("==================================");
  70.  
  71.         for (Map.Entry<String, HashMap<String, String>> me : czbk.entrySet()) {
  72.             String classNameKey = me.getKey();
  73.             HashMap<String, String> numNameMapValue = me.getValue();
  74.             for (Map.Entry<String, String> nameMapEntry : numNameMapValue.entrySet()) {
  75.                 String numKey = nameMapEntry.getKey();
  76.                 String nameValue = nameMapEntry.getValue();
  77.                 System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
  78.             }
  79.         }
  80.     }

17斗地主的功能分析

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

18斗地主的准备牌

  1. A:斗地主的准备牌 
  2.  
  3. /* 
    * 实现模拟斗地主的功能 
    * 1. 组合牌 
    * 2. 洗牌 
    * 3. 发牌 
    * 4. 看牌 
    */ 
    public class DouDiZhu { 
    public static void main(String[] args) { 
    　　//1. 组合牌 //创建Map集合,键是编号,值是牌 
    　　HashMap<Integer,String> pooker = new HashMap<Integer, String>(); 
  4.  
  5. 　　//创建List集合,存储编号 
    　　ArrayList<Integer> pookerNumber = new ArrayList<Integer>(); 
  6.  
  7. 　　//定义出13个点数的数组 
    　　String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"}; 
  8.  
  9. 　　//定义4个花色数组 String[] colors = {"♠","♥","♣","♦"}; 
  10.  
  11. 　　//定义整数变量,作为键出现 int index = 2; 
  12.  
  13. 　　//遍历数组,花色+点数的组合,存储到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);
  14.  }

19斗地主的洗牌

  1. A:斗地主的洗牌
  2.   /*
  3.    *  实现模拟斗地主的功能
  4.    *   1. 组合牌
  5.    *   2. 洗牌
  6.    *   3. 发牌
  7.    *   4. 看牌
  8.    */
  9.   public class DouDiZhu {
  10.     public static void main(String[] args) {
  11.         //1. 组合牌
  12.         //创建Map集合,键是编号,值是牌
  13.         HashMap<Integer,String> pooker = new HashMap<Integer, String>();
  14.         //创建List集合,存储编号
  15.         ArrayList<Integer> pookerNumber = new ArrayList<Integer>();
  16.         //定义出13个点数的数组
  17.         String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
  18.         //定义4个花色数组
  19.         String[] colors = {"♠","♥","♣","♦"};
  20.         //定义整数变量,作为键出现
  21.         int index = 2;
  22.         //遍历数组,花色+点数的组合,存储到Map集合
  23.         for(String number : numbers){
  24.             for(String color : colors){
  25.                 pooker.put(index, color+number);
  26.                 pookerNumber.add(index);
  27.                 index++;
  28.             }
  29.         }
  30.         //存储大王,和小王
  31.         pooker.put(0, "大王");
  32.         pookerNumber.add(0);
  33.         pooker.put(1, "小王");
  34.         pookerNumber.add(1);
  35.  
  36.         //洗牌,将牌的编号打乱
  37.         Collections.shuffle(pookerNumber);
  38.     }
  39.  
  40.   }

20斗地主的发牌

  1. A:斗地主的发牌 
    /* 
    * 实现模拟斗地主的功能 
    * 1. 组合牌 
    * 2. 洗牌 
    * 3. 发牌 
    * 4. 看牌 
    */ 
    public class DouDiZhu { 
    public static void main(String[] args) { 
  2.  
  3. //1. 组合牌 //创建Map集合,键是编号,值是牌 
    HashMap<Integer,String> pooker = new HashMap<Integer, String>(); 
  4.  
  5. //创建List集合,存储编号 ArrayList<Integer> pookerNumber = new ArrayList<Integer>(); 
  6.  
  7. //定义出13个点数的数组 String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"}; 
  8.  
  9. //定义4个花色数组 String[] colors = {"♠","♥","♣","♦"}; 
  10.  
  11. //定义整数变量,作为键出现 int index = 2; 
  12.  
  13. //遍历数组,花色+点数的组合,存储到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);
  14.  
  15.         //洗牌,将牌的编号打乱
  16.         Collections.shuffle(pookerNumber);
  17.  
  18.         //发牌功能,将牌编号,发给玩家集合,底牌集合
  19.         ArrayList<Integer> player1 = new ArrayList<Integer>();
  20.         ArrayList<Integer> player2 = new ArrayList<Integer>();
  21.         ArrayList<Integer> player3 = new ArrayList<Integer>();
  22.         ArrayList<Integer> bottom = new ArrayList<Integer>();
  23.  
  24.         //发牌采用的是集合索引%3
  25.         for(int i = 0 ; i < pookerNumber.size() ; i++){
  26.             //先将底牌做好
  27.             if(i < 3){
  28.                 //存到底牌去
  29.                 bottom.add( pookerNumber.get(i));
  30.                //对索引%3判断
  31.             }else if(i % 3 == 0){
  32.                 //索引上的编号,发给玩家1
  33.                 player1.add( pookerNumber.get(i) );
  34.             }else if( i % 3 == 1){
  35.                 //索引上的编号,发给玩家2
  36.                 player2.add( pookerNumber.get(i) );
  37.             }else if( i % 3 == 2){
  38.                 //索引上的编号,发给玩家3
  39.                 player3.add( pookerNumber.get(i) );
  40.             }
  41.         }
  42.     }
  43. }

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

  1. //洗牌,将牌的编号打乱
  2.          Collections.shuffle(pookerNumber);
  3.          //发牌功能,将牌编号,发给玩家集合,底牌集合
  4.          ArrayList<Integer> player1 = new ArrayList<Integer>();
  5.          ArrayList<Integer> player2 = new ArrayList<Integer>();
  6.          ArrayList<Integer> player3 = new ArrayList<Integer>();
  7.          ArrayList<Integer> bottom = new ArrayList<Integer>();
  8.          //发牌采用的是集合索引%3
  9.          for(int i = 0 ; i < pookerNumber.size() ; i++){
  10.              //先将底牌做好
  11.              if(i < 3){
  12.                  //存到底牌去
  13.                  bottom.add( pookerNumber.get(i));
  14.                 //对索引%3判断
  15.              }else if(i % 3 == 0){
  16.                  //索引上的编号,发给玩家1
  17.                  player1.add( pookerNumber.get(i) );
  18.              }else if( i % 3 == 1){
  19.                  //索引上的编号,发给玩家2
  20.                  player2.add( pookerNumber.get(i) );
  21.              }else if( i % 3 == 2){
  22.                  //索引上的编号,发给玩家3
  23.                  player3.add( pookerNumber.get(i) );
  24.              }
  25.          }
  26.          //对玩家手中的编号排序
  27.          Collections.sort(player1);
  28.          Collections.sort(player2);
  29.          Collections.sort(player3);
  30.          //看牌,将玩家手中的编号,到Map集合中查找,根据键找值
  31.          //定义方法实现
  32.          look("刘德华",player1,pooker);
  33.          look("张曼玉",player2,pooker);
  34.          look("林青霞",player3,pooker);
  35.          look("底牌",bottom,pooker);
  36.      }
  37.      public static void look(String name,ArrayList<Integer> player,HashMap<Integer,String> pooker){
  38.          //遍历ArrayList集合,获取元素,作为键,到集合Map中找值
  39.          System.out.print(name+" ");
  40.          for(Integer key : player){
  41.              String value = pooker.get(key);
  42.              System.out.print(value+" ");
  43.          }
  44.          System.out.println();
  45.      }
  46.  }

20_java之集合Map的更多相关文章

  1. Java集合Map接口与Map.Entry学习

    Java集合Map接口与Map.Entry学习 Map接口不是Collection接口的继承.Map接口用于维护键/值对(key/value pairs).该接口描述了从不重复的键到值的映射. (1) ...

  2. (10)集合之双列集合Map，HashMap，TreeMap

    Map中的元素是两个对象,一个对象作为键,一个对象作为值.键不可以重复,但是值可以重复. 看顶层共性方法找子类特有对象. Map与Collection在集合框架中属并列存在 Map存储的是键值对 Ma ...

  3. 【由浅入深理解java集合】(五)——集合 Map

    前面已经介绍完了Collection接口下的集合实现类,今天我们来介绍Map接口下的两个重要的集合实现类HashMap,TreeMap.关于Map的一些通用介绍,可以参考第一篇文章.由于Map与Lis ...

  4. (7)Java数据结构--集合map,set,list详解

    MAP,SET,LIST,等JAVA中集合解析(了解) - clam_clam的专栏 - CSDN博---有颜色, http://blog.csdn.net/clam_clam/article/det ...

  5. 双列集合Map

    1.双列集合Map,就是存储key-value的键值对. 2.hashMap中键必须唯一,值可以不唯一. 3.主要方法:put添加数据    getKey---通过key获取数据    keySet- ...

  6. 12：集合map、工具类

    一.map集合 Map:一次添加一对元素.Collection 一次添加一个元素. Map也称为双列集合,Collection集合称为单列集合. 其实map集合中存储的就是键值对(结婚证书), map ...

  7. Java集合—Map

    简介 Map用户保存具有映射关系的数据,因此Map集合里保存着两组数,一组值用户保存Map里的key,另一组值用户保存Map里的value,key和value都可以是任何引用类型的数据.Map的key ...

  8. Go语言【第十二篇】：Go数据结构之：切片(Slice)、范围(Range)、集合(Map)

    Go语言切片(Slice) Go语言切片是对数组的抽象,Go数组的长度不可改变,在特定场景中这样的集合就不太适用,Go中提供了一种灵活,功能强悍的内置类型切片("动态数组"),与数 ...

  9. 双列集合Map的嵌套遍历

    双列集合Map的嵌套使用,例如HashMap中还有一个HashMap,这样的集合遍历起来稍微有点儿复杂.例如一个集合:HashMap<Integer,HashMap<String,Inte ...

随机推荐

  1. libcurl使用认证证书 https认证

    在server.xml中增加下面的内容: ciphers="SSL_RSA_WITH_RC4_128_SHA" 下面是libcurl 的测试代码: #include <std ...

  2. 从客户端中检测到有潜在危险的 Request.Form 值的问题的解决方法。

    在controller控制器里面添加[ValidateInput(false)]         [ValidateInput(false)]        public ActionResult m ...

  3. 【剑指offer】11--旋转数组的最小数字（二分查找）

    原创博文,转载请注明出处! # 本文是牛客网<剑指offer>刷题笔记 1.题目 旋转数组的最小数字:输入一个非递减排序的数组的一个旋转,输出旋转数组的最小元素. 例如数组{3,4,5,1 ...

  4. 基本SQL命令

    1.SQL命令的使用规则 1.每条命令必须以 ; 结尾 2.SQL命令不区分字母大小写 3.使用 \c 来终止当前命令的执行 2.库的管理 1.库的基本操作 1.查看已有库 show database ...

  5. Android学习笔记之Toast详解

    1. 贴一段Android API-Toast Toast public class Toast  extends Object java.lang.Object ↳ android.widget.T ...

  6. Jmeter简单的接口测试

    1.新建线程组 2.编辑线程组信息 3.在线程组中添加HTTP信息头管理器 4.配置HTTP信息头管理器 参数格式配置 5.在线程组中添加HTTP请求 6.编辑HTTP请求信息 7.添加响应断言 8. ...

  7. css animation动画

    css 动画: 动画是CSS3中具有颠覆性的特征之一,可通过设置多个节点来精确控制一个或一组动画,常用来实现复杂的动画效果. 必要元素: a.通过@keyframes指定动画序列:自动补间动画,确定两 ...

  8. matlab调用c程序（转载）

    通过把耗时长的函数用c语言实现,并编译成mex函数可以加快执行速度. Matlab本身是不带c语言的编译器的,所以要求你的机器上已经安装有VC,BC或Watcom C中的一种. 如果你在安装Matla ...

  9. Sprint第一个冲刺（第五天）

    一.Sprint介绍 今天我们主要做的是修复乱码,完善项目. 任务进度: 二.Sprint周期 看板: 燃尽图:

  10. 关于git的基本使用

    参考:http://www.cnblogs.com/mengdd/p/3585038.html