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. ORA-19563: header validation failed for file
  2. SQL Server 列存储性能调优(翻译)
  3. 【讲义提纲】以一个实战新闻cms增删改查demo为例，给学院国创队伍培训php
  4. 数组API
  5. 解决ssh链接服务器超时自动断开的问题
  6. 安装Tomcat服务器
  7. chrome浏览器更新到chrome 29.0.1547.76 m，多出一些蛋疼的功能来。
  8. Google将向IETF标准提交QUIC协议提案
  9. 用pyinstaller打包python程序，解决打包时的错误：Cannot find existing PyQt5 plugin directories
  10. Shell命令-文件及目录操作之mkdir、mv
  11. Js 框架之Vue .JS学习记录 ① 与Vue 初识
  12. Ubuntu下查看SD卡设备名的几个方法
  13. C#中foreach命令的使用
  14. [译]课程 1: 使用 Quartz
  15. Series.str——字符串批量处理方法
  16. 总结Hibernate4.1+版本与Hibernate3.3+版本区别
  17. Linux C 结构体初始化三种形式
  18. hdu5125 树状数组+dp
  19. List of RGBD datasets
  20. 【摘】50个jQuery代码段帮助你成为一个更好的JavaScript开发者

热门文章

  1. 利用层序遍历（含空节点）和中序遍历重建二叉树 python
  2. iOS runloop 自定义输入源
  3. 使用vue
  4. Unity Obstacle分析
  5. JPA级联（一对一 一对多 多对多）注解【实际项目中摘取的】并非自己实际应用
  6. ssm框架实现图片上传显示并保存地址到数据库
  7. BZOJ3594: [Scoi2014]方伯伯的玉米田【二维树状数组优化DP】
  8. 【转载】分布式之redis复习精讲
  9. 《DSP using MATLAB》示例Example 6.27
  10. WinForm窗体继承自定义的模板窗体出错