Java——使用集合实现简单的斗地主发牌功能(两种方式简单粗暴!!!)

简介: Java——使用集合实现简单的斗地主发牌功能(两种方式简单粗暴!!!)

大家好啊!!!暑假在家,想必大家该追剧的追剧,该打游戏的打游戏,反正总会找点喜欢的事情去做,可以说是无忧无虑咯!!! 然而我却和 Java 集合打了一个星期的交道,不管怎样,也算是对集合有了一点了解吧。


所以,我就想着用刚学过的集合搞点什么有趣的小程序来感受一下编程的乐趣,因博主能力有限,思来想去,不如自己写一个模拟斗地主发牌的这样一个小程序吧!!!(虽然博主经常把欢乐斗输完,但还是很喜欢玩欢乐斗地主的。😁😁😁)


好了,话不多说,我用了下面这两种方式来实现斗地主发牌功能,如果你学过 Java 集合,那么这块内容理解起来对你一定不是问题,我在代码中也给出了详细的注释,我们一起来看一下吧:👇👇👇


方式1:(使用ArrayList集合实现无序发牌)


import java.util.*;
class FightAgainstLandlord {
  private ArrayList<String> poker;//poker集合存储54张牌
  private String[] colors;//colors数组存储牌的花色
  private String[] numbers;//numbers数组存储牌的大小
  //定义类的构造方法
  public FightAgainstLandlord(ArrayList<String> poker,String[] colors,String[] numbers) {
    this.poker=poker;
    this.colors=colors;
    this.numbers=numbers;
  }
  //存储54张牌
  public ArrayList<String> fiftyfive() {
    for(String color: colors) {
      for(String number: numbers) {
        //使用poker集合依次获取54张牌的花色和大小,例如:color 黑桃 + number 5
        poker.add(color + number);
      }
    }
    poker.add("大王");//我们在玩斗地主,所以别忘了还有大小王!!!
    poker.add("小王");
    //使用Collections工具类的shuffle()方法将获取到的54张牌的顺序打乱,也就是“洗牌”
    Collections.shuffle(poker);
    return poker;//这是一个使用泛型、接收集合的方法,最后要返回poker集合
  }
  public ArrayList<String> licensing(int k,ArrayList<String> poker) {
    /**获取三位玩家以及底牌
     * k=1,2,3分别代表三位玩家的牌
     * k=其他数字(在这里,我定义为4)代表底牌
     */
    //三位玩家和底牌需要创建成相应的集合来存储各自的牌
    ArrayList<String> player1=new ArrayList<String>();
    ArrayList<String> player2=new ArrayList<String>();
    ArrayList<String> player3=new ArrayList<String>();
    ArrayList<String> basepoker=new ArrayList<String>();
    for(int i=0;i<poker.size();i++) {//poker集合中存储了54张牌,使用size()方法获取集合中元素个数
      String card=poker.get(i);//使用get(index)方法返回该索引对应poker集合中的那张牌
      if(i<51) {//区间[0,51)一共51张牌,为玩家牌
        if(i%3==0) {//三位玩家按照顺序发牌,对3求余即可
          player1.add(card);//玩家1的牌
        }else if(i%3==1) {
          player2.add(card);//玩家2的牌
        }else {
          player3.add(card);//玩家3的牌
        }
      }else {
        basepoker.add(card);//底牌
      }
    }
    /**返回每位玩家各自的牌,以及底牌
     * 这是一个使用泛型、接收集合的方法,最后要返回相应的集合
     */
    if(k==1) {
      return player1;
    }else if(k==2) {
      return player2;
    }else if(k==3) {
      return player3;
    }else {
      return basepoker;
    }
  }
}
public class LandlordDemo {
  public static void main(String[] args) {
    ArrayList<String> poker=new ArrayList<String>();//创建一个ArrayList集合来存储扑克牌
    String[] colors= {"♠","♥","♦","♣"};//四种花色
    String[] numbers={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};//从A到K
    //这里我们new一个斗地主,使用构造方法创建一个实例对象
    FightAgainstLandlord fight=new FightAgainstLandlord(poker,colors,numbers);
    //再创建一个ArrayList集合去接收54张牌
    ArrayList<String> pokers=fight.fiftyfive();
    //获取三位玩家各自的17张牌,以及3张底牌
    ArrayList<String> player1=fight.licensing(1,pokers);
    ArrayList<String> player2=fight.licensing(2,pokers);
    ArrayList<String> player3=fight.licensing(3,pokers);
    ArrayList<String> basepoker=fight.licensing(4,pokers);
    //输出本次斗地主三位玩家分到的牌,以及3张底牌
    System.out.println("player1:" + player1);
    System.out.println("player2:" + player2);
    System.out.println("player3:" + player3);
    System.out.println("basepoker:" + basepoker);
  }
}



2.(使用HashMap、ArrayList、TreeSet集合实现有序发牌)


import java.util.*;
public class PokerDemo {
  public static void main(String[] args) {
    //创建一个HashMap集合,键对应牌的编号Integer类型,值对应牌的大小String类型
    HashMap<Integer,String> hashmap=new HashMap<Integer,String>();
    //创建一个ArrayList集合,存储牌的编号
    ArrayList<Integer> arraylist=new ArrayList<Integer>();
    //创建牌的花色数组
    String[] colors={"♠","♥","♦","♣"};
    //创建牌的大小数组
    String[] numbers={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
    //索引从0开始向hashmap集合中存储牌的编号的大小,向arraylist集合中存储牌的编号
    int index=0;
    for(String number : numbers) {
      for(String color : colors) {
        //使用String类的concat()方法连接字符串,显然是将牌的大小连接到花色后面
        String poker=color.concat(number);//例如:color 红桃 + number 5
        hashmap.put(index,poker);//将每张牌对应的编号存储在hashmap集合的键中
        arraylist.add(index);//将每张牌的编号同样存储在arraylist集合中
        index++;//每存储一张牌,编号加1
      }
    }
    //我们玩的是斗地主,所以别忘了还有大小王哦!!!
    hashmap.put(index,"大王");//存入大王
    arraylist.add(index);//大王对应的编号
    index++;//编号加1
    hashmap.put(index,"小王");//存入小王
    arraylist.add(index);//小王对应的编号
    /*使用Collections工具类的shuffle()方法将牌的编号顺序打乱
      因为每张牌的都有对应的编号,所以将牌的编号打乱,也就是将牌的花色大小给打乱*/
    Collections.shuffle(arraylist);//俗称“洗牌”
    //发牌:为了保证发出的牌类似欢乐斗地主那样是排好序的,所以这里我们使用TreeSet集合接收
    TreeSet<Integer> player1=new TreeSet<Integer>();//玩家1
    TreeSet<Integer> player2=new TreeSet<Integer>();//玩家2
    TreeSet<Integer> player3=new TreeSet<Integer>();//玩家3
    TreeSet<Integer> basepoker=new TreeSet<Integer>();//底牌
    for(int i=0;i<arraylist.size();i++) {//arraylist集合的长度为54,下标则是从0到53
      if(i<51) {//前51张牌按顺序依次发给3位玩家
        if(i%3==0) {
          //这里通过ArrayList集合中的get(index)方法获取索引i对应的牌的编号
          player1.add(arraylist.get(i));
        }else if(i%3==1) {
          player2.add(arraylist.get(i));
        }else {
          player3.add(arraylist.get(i));
        }
      }else {
        basepoker.add(arraylist.get(i));
      }
    }
    //通过遍历TreeSet集合,获取牌的编号,进而到HashMap集合中找到对应牌的花色大小
    PokerDemo.licensing("player1:",player1,hashmap);
    PokerDemo.licensing("player2:",player2,hashmap);
    PokerDemo.licensing("player3:",player3,hashmap);
    PokerDemo.licensing("basepoker:",basepoker,hashmap);
  }
  public static void licensing(String name,TreeSet<Integer> ts,HashMap<Integer,String> hashmap) {
    System.out.print(name + "[");
    int num=0;
    for(Integer key : ts) {//遍历形参中的每一个TreeSet集合
      //通过HashMap集合中的get(key)方法获取键对应的值(也就是牌的编号对应牌的花色大小)
      String value=hashmap.get(key);
      //这里的if-else是控制一下输出格式,保证最后一张牌的后面没有多余的逗号
      if(num<ts.size()-1) {
        System.out.print(value + " , ");
      }else {
        System.out.print(value);
      }
      num++;
    }
    System.out.println("]");
  }
}


相关文章
|
4天前
|
存储 安全 Java
Java 集合框架中的老炮与新秀:HashTable 和 HashMap 谁更胜一筹?
嗨,大家好,我是技术伙伴小米。今天通过讲故事的方式,详细介绍 Java 中 HashMap 和 HashTable 的区别。从版本、线程安全、null 值支持、性能及迭代器行为等方面对比,帮助你轻松应对面试中的经典问题。HashMap 更高效灵活,适合单线程或需手动处理线程安全的场景;HashTable 较古老,线程安全但性能不佳。现代项目推荐使用 ConcurrentHashMap。关注我的公众号“软件求生”,获取更多技术干货!
23 3
|
24天前
|
Java
java实现从HDFS上下载文件及文件夹的功能,以流形式输出,便于用户自定义保存任何路径下
java实现从HDFS上下载文件及文件夹的功能,以流形式输出,便于用户自定义保存任何路径下
86 34
|
21天前
|
存储 缓存 安全
Java 集合江湖:底层数据结构的大揭秘!
小米是一位热爱技术分享的程序员,本文详细解析了Java面试中常见的List、Set、Map的区别。不仅介绍了它们的基本特性和实现类,还深入探讨了各自的使用场景和面试技巧,帮助读者更好地理解和应对相关问题。
37 5
|
2月前
|
存储 缓存 安全
Java 集合框架优化:从基础到高级应用
《Java集合框架优化:从基础到高级应用》深入解析Java集合框架的核心原理与优化技巧,涵盖列表、集合、映射等常用数据结构,结合实际案例,指导开发者高效使用和优化Java集合。
43 4
|
2月前
|
Java
Java 8 引入的 Streams 功能强大,提供了一种简洁高效的处理数据集合的方式
Java 8 引入的 Streams 功能强大,提供了一种简洁高效的处理数据集合的方式。本文介绍了 Streams 的基本概念和使用方法,包括创建 Streams、中间操作和终端操作,并通过多个案例详细解析了过滤、映射、归并、排序、分组和并行处理等操作,帮助读者更好地理解和掌握这一重要特性。
37 2
|
2月前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
2月前
|
存储 Java 开发者
Java中的集合框架深入解析
【10月更文挑战第32天】本文旨在为读者揭开Java集合框架的神秘面纱,通过深入浅出的方式介绍其内部结构与运作机制。我们将从集合框架的设计哲学出发,探讨其如何影响我们的编程实践,并配以代码示例,展示如何在真实场景中应用这些知识。无论你是Java新手还是资深开发者,这篇文章都将为你提供新的视角和实用技巧。
36 0
|
安全 算法 Java
Java 17 新功能介绍(LTS)
Java 17 新功能介绍(LTS)
705 0
Java 17 新功能介绍(LTS)
|
Java 测试技术 API
Java 18 新功能介绍
Java 18 新功能介绍
327 0
Java 18 新功能介绍
|
JavaScript 前端开发 算法
超详细 Java 15 新功能介绍
超详细 Java 15 新功能介绍
177 0
超详细 Java 15 新功能介绍