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

     }

 }

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. 构造字典：DictionaryBase类和SortedList类

    DictionaryBase 类 msdn对DictionaryBase的文档解释 泛型KeyValuePair类 msdnd对泛型KeyValuePair类的文档解释 SortedList类 RUN ...

  2. 数据库备份mysqldump

    |--好友说:有些知识就是石头,走上这条路就没法绕过,就是牙齿啃碎了也要把它啃下来. ------------------------------------------ 针对当前备份做一个总结记忆: ...

  3. [转]redis服务器与客户端保活参数（tcp-keepalive）设置

    最近使用redis的list做跨进程的消息队列,客户端使用的是redis-cplusplus-client.这个client库还是蛮好用的,提供了和redis命令行一致的接口,很方便. 使用过程中发现 ...

  4. Cookie用法

    //写入 protected void Button1_Click(object sender, EventArgs e) { HttpCookie cookie=new HttpCookie(&qu ...

  5. 简单实现Jmail发送邮件

    package com.chauvet.util; import java.util.Properties; import javax.mail.*; import javax.mail.intern ...

  6. Appium+python (3) 元素定位（1）

    打开问价夹下面的uiautomatorviewer: 夜神模拟器里的App后,回到uiautomatorviewer: 点击左上角的Device Screenshot,这时你的夜神模拟器页面就会显示在 ...

  7. BZOJ AC倒序总结

    https://fcw.moe/?p=177

  8. vue踩坑记录

    一.element resetFields 方法报错 网上查的解决方案 resetForm(formName) { this.$nextTick(() => { this.$refs[formN ...

  9. scrapy docker 基本部署使用

    1. 简单项目 pip install scrapy scrapy startproject appdemo     2. 项目代码 a. 项目代码结构 ├── Dockerfile ├── READ ...

  10. hash一致性算法

    一致性hash算法是,1097麻省理工提出的分布式hashDHT实现算法,极倔internet的热点问题 平衡性 hash结果尽可能的分布到所有的缓存中去,缓冲空间利用率最高 单调性 保持已有的缓存能 ...