集合综合案例

ゝ一纸荒年。 2024-03-27 17:51 83阅读 0赞

### 综合案例 ###

#### 1. 随机点名 ####

班级里有n个学生
                学生属性：姓名，年龄，性别
                实现随机点名器

package com.test;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Random;
    
    public class Test01 {
        
        public static void main (String[] args) {
        
            /*
                班级里有n个学生
                    学生属性：姓名，年龄，性别
                    实现随机点名器
             */
    
            //1. 创建集合对象
            ArrayList<String> list = new ArrayList<> ();
            //2. 添加数据
            Collections.addAll (list,"杨志飞","马紫雨","翁蕊","杨坤","刘柏良","王兴旺","张梓然","张宏涛",
                    "李文帅","程军帅","宫和坤","马健","王安","付立臣","高瑞","张泽坤","韩立帅");
            //3. 随机点名
            /*Random r =  new Random ();
    
            int index = r.nextInt (list.size ());
            String name = list.get (index);
            System.out.println (name);*/
    
            //打乱
            Collections.shuffle (list);
            String name = list.get (0);
            System.out.println (name);
        }
    }

#### 2.有概率的随机点名 ####

班级有N个学生
            要求：
                70%概率男生
                30%概率女生

package com.test;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Random;
    
    public class Test02 {
        
        public static void main (String[] args) {
        
            /*
                班级有N个学生
                要求：
                    70%概率男生
                    30%概率女生
             */
    
            ArrayList<Integer> list = new ArrayList<> ();
    
            Collections.addAll (list,1,1,1,1,1,1,1);
            Collections.addAll (list,0,0,0);
    
            Collections.shuffle (list);
    
            System.out.println (list);
    
            //1. 从list中随机抽取0或者1
            Random r = new Random ();
            int index = r.nextInt (list.size ());
            int number = list.get (index);
            System.out.println (number);
    
            //创建两个集合，分别存储男生女生名字
            ArrayList<String> boyList = new ArrayList<> ();
            ArrayList<String> girlList = new ArrayList<> ();
    
            Collections.addAll (boyList,"程军帅","宫和坤","马健","王安","付立臣","高瑞","张泽坤","韩立帅");
            Collections.addAll (girlList,"李沁","李一桐","杨钰莹","杨幂","杨颖","白梦妍","杨超越","赵丽颖");
    
            //判断是从那个集合抽取
            if (number==1){
        
                //boyList
                System.out.println (boyList.get (r.nextInt (boyList.size ())));
            }else {
        
                //girlList
                System.out.println (girlList.get (r.nextInt (girlList.size ())));
            }
    
        }
    }

#### 3. 不重复的点名 ####

班级里有N个学生
    要求：
    	被点到的学生不会再被点到
    	但是如果班级里的学生都点完了，需要重新开启第二轮点名

package com.test;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Random;
    
    public class Test03 {
        
        public static void main (String[] args) {
        
            /*
            班级里有N个学生
    	    要求：
                被点到的学生不会再被点到
                但是如果班级里的学生都点完了，需要重新开启第二轮点名
             */
    
            //1. 创建集合对象
            ArrayList<String> list1 = new ArrayList<> ();
            //2. 添加数据
            Collections.addAll (list1,"杨志飞","马紫雨","翁蕊","杨坤","刘柏良","王兴旺","张梓然","张宏涛",
                    "李文帅","程军帅","宫和坤","马健","王安","付立臣","高瑞","张泽坤","韩立帅");
    
            //创建一个临时的集合，用于存放已经被点到过的学生姓名
            ArrayList<String> list2 = new ArrayList<> ();
    
            //外循环，表示轮数；内循环，每一轮随机抽取的过程
            for (int j = 1; j <= 10; j++) {
        
    
                System.out.println ("================第"+j+"轮点名开始了================");
            //3. 获取集合长度
            int size = list1.size ();
            //4. 随机点名
            Random r =  new Random ();
    
            for (int i = 0; i < size; i++) {
        
            int index = r.nextInt (list1.size ());
            /*String name = list.get (index);
            list.remove (index);*/
            String name = list1.remove (index);
            list2.add (name);
            System.out.println (name);
            }
    
            //此时表示一轮点名已经结束
            /*System.out.println (list1);
            System.out.println (list2);*/
            list1.addAll (list2);
            list2.clear ();
            }
    
        }
    }

#### 4. Map集合 ####

需求：
    定义一个Map集合，键表示省份名称province ，值表示市city，但是市会有多个
    遍历格式：
    江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
    湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
    河北省 = 沧州市，保定市，唐山市，衡水市，邢台市

package com.test;
    
    import java.util.*;
    
    public class Test04 {
        
        public static void main (String[] args) {
        
    
            /*
               	需求：
                定义一个Map集合，键表示省份名称province ，值表示市city，但是市会有多个
                遍历格式：
                江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
                湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
                河北省 = 沧州市，保定市，唐山市，衡水市，邢台市
             */
            HashMap<String, ArrayList<String>> hm = new HashMap<> ();
    
            //存储市
            ArrayList<String> city1 = new ArrayList<> ();
            Collections.addAll (city1,"南京市","扬州市","苏州市","无锡市","常州市");
    
            ArrayList<String> city2 = new ArrayList<> ();
            Collections.addAll (city2,"武汉市","孝感市","十堰市","宜昌市","鄂州市");
    
            ArrayList<String> city3 = new ArrayList<> ();
            Collections.addAll (city3,"沧州市","保定市","唐山市","衡水市","邢台市");
    
            hm.put ("江苏省",city1);
            hm.put ("湖北省",city2);
            hm.put ("河北省",city3);
    
            System.out.println (hm);
    
            for (String key : hm.keySet ()) {
        
                 ArrayList<String> value = hm.get (key);
                 StringJoiner stringJoiner = new StringJoiner (", ","","");
                for (String city : value) {
        
                    stringJoiner.add (city);
                }
                System.out.println (key + "=" +stringJoiner);
            }
    
            for (Map.Entry<String, ArrayList<String>> entry : hm.entrySet ()) {
        
                String key = entry.getKey ();
                ArrayList<String> value = entry.getValue ();
                StringBuilder stringBuilder = new StringBuilder ();
                stringBuilder = stringBuilder.append (key).append ("=").append (value);
                System.out.println (stringBuilder);
            }
        }
    }

#### 斗地主1（控制台版） ####

完成控制台的三步：
    		        1. 准备牌
    		        2. 洗牌
    		        3. 发牌

package com.doudizhu1;
    
    import java.util.ArrayList;
    import java.util.Collections;
    
    public class PokerGame {
        
    
        //牌盒
        static ArrayList<String> list = new ArrayList<> ();
    
        //静态代码块：只执行一次
        static {
        
              //准备牌
            //"♦","♥","♣","♠"
            //"3","4","5","6","7","8","9","10","J","Q","K","A","2"
            String[] color = {
        "♦","♥","♣","♠"};
            String[] number = {
        "3","4","5","6","7","8","9","10","J","Q","K","A","2"};
    
            for (String c : color) {
        
                //c依次表示每一种花色
                for (String n : number) {
        
                    //n依次表示数字
                    list.add (c+n);
                }
            }
    
            list.add ("小王");
            list.add ("大王");
        }
    
        public PokerGame () {
        
            //洗牌
            Collections.shuffle (list);
    
            //发牌
            ArrayList<String> bottomCard = new ArrayList<> ();
            ArrayList<String> player1 = new ArrayList<> ();
            ArrayList<String> player2 = new ArrayList<> ();
            ArrayList<String> player3 = new ArrayList<> ();
    
            //遍历牌盒，得到每一张牌
            for (int i = 0; i < list.size (); i++) {
        
                String poker = list.get (i);
                if (i<=2){
        
                    bottomCard.add (poker);
                    continue;
                }
    
                //给三个轮流发牌
                if (i % 3 == 0){
        
                    player1.add (poker);
                } else if (i % 3 == 1) {
        
                    player2.add (poker);
                }else {
        
                    player3.add (poker);
                }
            }
    
            //看牌
            lookPoker ("底牌",bottomCard);
            lookPoker ("钢脑壳",player1);
            lookPoker ("大帅比",player2);
            lookPoker ("蛋筒",player3);
    
    
        }
    
        /*
        * 参数一：玩家名字
        * 参数二：每位玩家的牌
        * */
        public void lookPoker(String name,ArrayList<String> list){
        
            System.out.print (name + ": ");
    
            for (String poker : list) {
        
                System.out.print (poker+" ");
            }
            System.out.println ();
        }
    }

#### 斗地主2（控制台版） ####

完成控制台的三步：
    		        1. 准备牌
    		        2. 洗牌
    		        3. 发牌
    		        4. 排序（两种方式排序）	方式一：利用序号排序
    															方式二：给每一张牌计算价值

##### 方式一：利用序号排序 #####

package com.doudizhu2;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.TreeSet;
    
    public class PokerGame {
        
        //牌盒
        //此时我们只需要把牌和序号产生对应关系就可以了，不需要按照序号进行排序，所以只需要HashMap就可以了
        static HashMap<Integer,String> hm = new HashMap<> ();
        static ArrayList<Integer> list = new ArrayList<> ();
    
        //静态代码块：只执行一次
        static {
        
            //准备牌
            //"♦","♥","♣","♠"
            //"3","4","5","6","7","8","9","10","J","Q","K","A","2"
            String[] color = {
        "♦", "♥", "♣", "♠"};
            String[] number = {
        "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    
            //序号
            int serialNumber = 1;
    
            //细节
            for (String n : number) {
        
                    //n依次表示数字
                for (String c : color) {
        
                //c依次表示每一种花色
                    hm.put (serialNumber,c+n);
                    list.add (serialNumber);
                    serialNumber++;
                }
            }
    
            hm.put (serialNumber,"小王");
                    list.add (serialNumber);
            serialNumber++;
            hm.put (serialNumber,"大王");
                    list.add (serialNumber);
            System.out.println (hm);
    
        }
    
        public PokerGame(){
        
            //洗牌
            Collections.shuffle (list);
    
            //发牌
            TreeSet<Integer> bottomCard = new TreeSet<> ();
            TreeSet<Integer> player1 = new TreeSet<> ();
            TreeSet<Integer> player2 = new TreeSet<> ();
            TreeSet<Integer> player3 = new TreeSet<> ();
    
            for (int i = 0; i < list.size (); i++) {
        
                //i依次表示集合中的每一个索引
                //list.get (i)元素：牌的序号
                Integer serialNumber = list.get (i);
    
                if (i <= 2){
        
                    bottomCard.add (serialNumber);
                    continue;
                }
    
                if (i % 3 == 0){
        
                    player1.add (serialNumber);
                } else if (i % 3 == 1) {
        
                    player2.add (serialNumber);
                }else {
        
                    player3.add (serialNumber);
                }
            }
    
    /*        System.out.println (bottomCard);
            System.out.println (player1);
            System.out.println (player2);
            System.out.println (player3);*/
    
            //看牌
            lookPoker ("底牌",bottomCard);
            lookPoker ("钢脑壳",player1);
            lookPoker ("大帅比",player2);
            lookPoker ("蛋 筒",player3);
    
    
    
        }
    
        public void lookPoker(String name,TreeSet<Integer> treeSet){
        
            System.out.print (name+": ");
            //遍历集合，得到每一个序号，再拿着序号到Map集合中，找到真正的牌
            for (Integer serialNumber : treeSet) {
        
                String poker = hm.get (serialNumber);
                System.out.print (poker+" ");
            }
            System.out.println ();
        }
    }

##### 方式二：给每一张牌计算价值 #####

package com.doudizhu3;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    
    public class PokerGame {
        
    
        //牌盒
        static ArrayList<String> list = new ArrayList<> ();
    
        //创建一个集合，用来添加牌的价值
        static HashMap<String,Integer> hm = new HashMap<> ();
    
        //静态代码块：只执行一次
        static {
        
            //准备牌
            String[] color = {
        "♦","♥","♣","♠"};
            String[] number = {
        "3","4","5","6","7","8","9","10","J","Q","K","A","2"};
    
            for (String c : color) {
        
                //c依次表示每一种花色
                for (String n : number) {
        
                    //n依次表示数字
                    list.add (c+n);
                }
            }
    
            list.add (" 小王");
            list.add (" 大王");
    
            //指定牌的价值
            //牌上的数字到Map集合中判断是否存在
            //存在，获取价值，；不存在，数字本身就是价值
            hm.put ("J",11);
            hm.put ("Q",12);
            hm.put ("K",13);
            hm.put ("A",14);
            hm.put ("2",15);
            hm.put ("小王",50);
            hm.put ("大王",100);
    
        }
    
        public PokerGame () {
        
            //洗牌
            Collections.shuffle (list);
    
            //发牌
            ArrayList<String> bottomCard = new ArrayList<> ();
            ArrayList<String> player1 = new ArrayList<> ();
            ArrayList<String> player2 = new ArrayList<> ();
            ArrayList<String> player3 = new ArrayList<> ();
    
            //遍历牌盒，得到每一张牌
            for (int i = 0; i < list.size (); i++) {
        
                String poker = list.get (i);
                if (i<=2){
        
                    bottomCard.add (poker);
                    continue;
                }
    
                //给三个轮流发牌
                if (i % 3 == 0){
        
                    player1.add (poker);
                } else if (i % 3 == 1) {
        
                    player2.add (poker);
                }else {
        
                    player3.add (poker);
                }
            }
    
    
            //排序
            order (bottomCard);
            order (player1);
            order (player2);
            order (player3);
    
            //看牌
            lookPoker ("底牌",bottomCard);
            lookPoker ("钢脑壳",player1);
            lookPoker ("大帅比",player2);
            lookPoker ("蛋 筒",player3);
    
    
        }
    
        //利用牌的价值，进行排序；参数：集合
        public void order(ArrayList<String> list){
        
            Collections.sort (list, new Comparator<String> () {
        
                //Arrays.sort   （插入排序+二分查找）
                @Override
                public int compare (String o1, String o2) {
        
                    /*o1 ：表示当前要插入到有序序列的牌
                    o2 ： 表示已经在有序序列中的牌
                    负数：o1小 插入到前面
                    正数：o1大 插入到后面
                    0：表示o1和o2 的数字一样大，需要按照花色再次排序
                    */
    
                    //1. 计算o1的花色和价值
                    String color1 = o1.substring (0,1);
                    int value1 = getValue (o1);
    
                    //2. 计算o2的花色和价值
                    String color2 = o2.substring (0,1);
                    int value2 = getValue (o2);
    
                    //3. 比较o1和o2 的价值
                    int i = value1 -value2;
    
                    return i == 0 ? color1.compareTo (o2) : i;
                }
            });
    
        }
    
        /*
            计算牌的价值
                参数：牌
                返回值：牌的价值
         */
        public int getValue(String poker){
        
            //获取牌上的数字
            String number = poker.substring (1);
            //拿着数字到map集合中判断是否存在，存在，获取价值；不存在，类型转换
            if (hm.containsKey (number)){
        
                //存在
                return hm.get (number);
            }else {
        
                return Integer.parseInt (number);
            }
        }
        /*
         * 参数一：玩家名字
         * 参数二：每位玩家的牌
         * */
        public void lookPoker(String name,ArrayList<String> list){
        
            System.out.print (name + ": ");
    
            for (String poker : list) {
        
                System.out.print (poker+" ");
            }
            System.out.println ();
        }
    
    }

#### 斗地主3（页面版） ####