Java数据结构之基于ArrayList编写大众麻将和扑克牌洗牌小练习

简介: 本文讲解:Java数据结构之基于ArrayList编写大众麻将和扑克牌洗牌小练习

 image.gif编辑

 

目录

1.大众麻将洗牌小程序

1.1实现效果

1.2源码展示

2.扑克牌洗牌小程序

2.1实现效果

2.2源码展示

image.gif编辑

1.大众麻将洗牌小程序

大众麻将有3种牌色分别为万、条、筒。每种牌色有9张,如一万到九万。每种牌色有四张,因此万、条、筒*9*4一共108张。因此,设计洗牌流程如下。

    1. 初始化牌面,使用一维数组或二维数组,博主用的是二维数组。
    2. 洗牌,使用ArrayList中的get、set方法,再搭配一些自定义的方法。
    3. 揭牌,给四个人分配牌,我们可以使用二维ArrayList存储每个人的牌面。
    4. 打印剩余牌面,直接打印剩余二维ArrayList中的牌面。

    1.1实现效果

    (1)打印、洗牌

    image.gif编辑

    (2)四人牌面展示、剩余牌面展示

    image.gif编辑


    1.2源码展示

    (1)Test.java

    import java.util.ArrayList;
    import java.util.List;
    import java.util.Scanner;
    //大众麻将通常情况下四人为一局游戏,每个人拿13张牌
    public class Test  {
        public static void shows() {
            //实例化一个Play类的对象
            Play play = new Play();
            //String类型的一维顺序表
            List<String> list = play.buyMaJiang(new ArrayList<>());
            //String类型的二维顺序表
            List<List<String>> lists = new ArrayList<>();
            //打印出牌面
            System.out.println("牌面为万、条、筒:");
            for (int i = 0; i < 4; i++) {
                System.out.println(list);
            }
            System.out.println("共108张!");
            System.out.println("========================================分割线=========================================");
            //打印出洗牌后的牌面
            System.out.println("洗牌:");
            for (int i = 0; i < 4; i++) {
                play.xiPai(list);
                lists.add(new ArrayList<>(list));
                System.out.println(list);
            }
            System.out.println("========================================分割线=========================================");
            for (int i = 0; i < 4; i++) {
                System.out.print("第"+(i+1)+"个人牌面为:");
                for (int j = 0; j < 13; j++) {
                    System.out.print(lists.get(i).get(j)+" ");
                    lists.get(i).remove(j);
                }
                System.out.println();
            }
            System.out.println("========================================分割线=========================================");
            System.out.println("剩余牌面:");
            for (int i = 0; i < 4; i++) {
                System.out.println(lists.get(i));
            }
    }
        public static void main(String[] args) {
            shows();
        }
    }

    image.gif

    (2)MaJiang.java

    public class MaJiang {
        //初始化麻将,一个二维数组
        public static final String[][] CardFace = {
                {"\uD83C\uDC07","\uD83C\uDC08","\uD83C\uDC09","\uD83C\uDC0A",
                "\uD83C\uDC0B","\uD83C\uDC0C","\uD83C\uDC0D","\uD83C\uDC0E","\uD83C\uDC0F"
                },
                {"\uD83C\uDC10","\uD83C\uDC11","\uD83C\uDC12","\uD83C\uDC13",
                "\uD83C\uDC14","\uD83C\uDC15","\uD83C\uDC16","\uD83C\uDC17","\uD83C\uDC18"
                },
                {"\uD83C\uDC19","\uD83C\uDC1A","\uD83C\uDC1B","\uD83C\uDC1C",
                "\uD83C\uDC1D","\uD83C\uDC1E","\uD83C\uDC1F","\uD83C\uDC20","\uD83C\uDC21"
                }
                };
    }

    image.gif

    (3)Play.java

    import java.util.List;
    import java.util.Random;
    public class Play extends MaJiang {
        //购买一副牌
        public List<String> buyMaJiang(List<String> maJiangs) {
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 9; j++) {
                    /*MaJiang maJiang  = new MaJiang();*/
                    maJiangs.add(CardFace[i][j]);
                }
            }
            return  maJiangs;
        }
        //洗牌
        public void xiPai(List<String> maJiangs) {
            for (int i = maJiangs.size()-1; i >0 ; i--) {
                Random random = new Random();
                int str = random.nextInt(i);
                swap(maJiangs,i,str);
            }
        }
        //交换
        private void swap(List<String> maJiangs,int i,int j) {
            String tmp = maJiangs.get(j);
            maJiangs.set(j,maJiangs.get(i));
            maJiangs.set(i,tmp);
        }
    }

    image.gif


    2.扑克牌洗牌小程序

    扑克牌一共有六种花色,红桃、黑桃、梅花、方块、大王、小王。在此程序中,我们不考虑大小王。每种花色从1-13(A-K),因此一共有4*13=52张牌。设计思想如下:

      1. 构造出四种花色,使用一维数组。
      2. 洗牌,使用ArrayList中使用get、set方法加上一些自定义方法来实现。
      3. 揭牌,没揭一张牌,我们使用remove来去除该牌下标。

      2.1实现效果

      image.gif编辑


      2.2源码展示

      (1)Test.java

      package demo;
      import java.util.ArrayList;
      import java.util.List;
      public class Test {
          public static void main(String[] args) {
              //实例化出一个Game类型的对象
              Game game = new Game();
              //实例化一个泛型类Poker
              List<Poker> pokers = game.disPlay(new ArrayList<>());
              //打印出顺序表
              System.out.println("牌面为:");
              game.disPlay(pokers);
              System.out.println(pokers);
              //实例化一个二维顺序表
              List<List<Poker>> lists = game.play(pokers);
              //打印三个人的牌面
              for (int i = 0; i < 3; i++) {
                  System.out.print("第"+(i+1)+"个人为:"+lists.get(i));
                  System.out.println();
              }
              //打印剩余的牌
              System.out.println("剩余的牌为:");
              System.out.println(pokers);
          }
      }

      image.gif

      (2)Poker.java

      package demo;
      public class Poker {
          //花色
          private String huaSe;
          //数字
          private int number;
          //提供一个构造方法,方便我们设置扑克牌
          public Poker(String huaSe, int number) {
              this.huaSe = huaSe;
              this.number = number;
          }
          //重写toString方法,使打印的并非地址值
          @Override
          public String toString() {
              return huaSe+" "+number;
          }
      }

      image.gif

      (3)Game.java

      package demo;
      import java.util.ArrayList;
      import java.util.List;
      import java.util.Random;
      public class Game {
          private static final String[] card= {"♠","♦","♥","♣"};
          //打印扑克牌
          public List<Poker> disPlay(List<Poker> pokers) {
              for (int i = 0; i < 4; i++) {
                  for (int j = 1; j <= 13; j++) {
                      Poker poker = new Poker(card[i],j);
                      pokers.add(poker);
                  }
              }
              return pokers;
          }
          //玩牌
          public List<List<Poker>> play(List<Poker> pokers) {
              //实例出一个二维顺序表
              List<List<Poker>> lists = new ArrayList<>();
              //实例出三个顺序表,三个玩家
              List<Poker> list1 = new ArrayList<>();
              List<Poker> list2 = new ArrayList<>();
              List<Poker> list3 = new ArrayList<>();
              lists.add(list1);
              lists.add(list2);
              lists.add(list3);
              //随机生成某个下标
              for (int i = pokers.size()-1; i >0 ; i--) {
                  Random random = new Random();
                  int num = random.nextInt(i);
                  //调用swap使随机生成的下标值与i值互换
                  swap(pokers,num,i);
              }
              //二维顺序表存储中一维顺序表存储数据
              for (int i = 0; i <5 ; i++) {
                  for (int j = 0; j < 3; j++) {
                      Poker removePoker = pokers.remove(0);
                      lists.get(j).add(removePoker);
                  }
              }
              return lists;
          }
          //打乱扑克牌
          public void swap(List<Poker> pokers,int i,int j) {
              Poker tmp = pokers.get(j);
              pokers.set(j,pokers.get(i));
              pokers.set(i,tmp);
          }
      }

      image.gif


      本期博客,主要是为了针对ArrayList顺序表-进行设计的两个小练习,大家也可以设置出自己想要编写的程序,快去试试吧~

      相关文章
      |
      4月前
      |
      人工智能 安全 JavaScript
      Java ArrayList:动态数组
      本文探讨Java中的数组,对比C/C++、JS/PHP/Python等语言的数组特性。文章分析了Java数组的定义、创建方式及其规范,指出其优缺点。Java数组作为引用类型,在堆上分配内存,支持动态大小,避免了C/C++中裸数组的常见问题(如越界访问)。然而,Java数组也存在性能瓶颈和设计缺陷,例如运行时的安全检查影响速度,无法创建超大数组或泛型数组,且多线程场景下缺乏同步机制。作者建议在实际开发中用集合替代数组以规避这些问题。
      110 1
      |
      5月前
      |
      前端开发 Java
      java实现队列数据结构代码详解
      本文详细解析了Java中队列数据结构的实现,包括队列的基本概念、应用场景及代码实现。队列是一种遵循“先进先出”原则的线性结构,支持在队尾插入和队头删除操作。文章介绍了顺序队列与链式队列,并重点分析了循环队列的实现方式以解决溢出问题。通过具体代码示例(如`enqueue`入队和`dequeue`出队),展示了队列的操作逻辑,帮助读者深入理解其工作机制。
      150 1
      |
      2月前
      |
      Java 索引
      Java ArrayList中的常见删除操作及方法详解。
      通过这些方法,Java `ArrayList` 提供了灵活而强大的操作来处理元素的移除,这些方法能够满足不同场景下的需求。
      344 30
      |
      3月前
      |
      存储 安全 Java
      Java 集合面试题从数据结构到 HashMap 源码剖析详解及长尾考点梳理
      本文深入解析Java集合框架,涵盖基础概念、常见集合类型及HashMap的底层数据结构与源码实现。从Collection、Map到Iterator接口,逐一剖析其特性与应用场景。重点解读HashMap在JDK1.7与1.8中的数据结构演变,包括数组+链表+红黑树优化,以及put方法和扩容机制的实现细节。结合订单管理与用户权限管理等实际案例,展示集合框架的应用价值,助你全面掌握相关知识,轻松应对面试与开发需求。
      187 3
      |
      11月前
      |
      存储 Java
      Java中的HashMap和TreeMap,通过具体示例展示了它们在处理复杂数据结构问题时的应用。
      【10月更文挑战第19天】本文详细介绍了Java中的HashMap和TreeMap,通过具体示例展示了它们在处理复杂数据结构问题时的应用。HashMap以其高效的插入、查找和删除操作著称,而TreeMap则擅长于保持元素的自然排序或自定义排序,两者各具优势,适用于不同的开发场景。
      118 1
      |
      5月前
      |
      存储 Java 编译器
      Java 中 .length 的使用方法:深入理解 Java 数据结构中的长度获取机制
      本文深入解析了 Java 中 `.length` 的使用方法及其在不同数据结构中的应用。对于数组,通过 `.length` 属性获取元素数量;字符串则使用 `.length()` 方法计算字符数;集合类如 `ArrayList` 采用 `.size()` 方法统计元素个数。此外,基本数据类型和包装类不支持长度属性。掌握这些区别,有助于开发者避免常见错误,提升代码质量。
      422 1
      |
      10月前
      |
      Java 索引 容器
      Java ArrayList扩容的原理
      Java 的 `ArrayList` 是基于数组实现的动态集合。初始时,`ArrayList` 底层创建一个空数组 `elementData`,并设置 `size` 为 0。当首次添加元素时,会调用 `grow` 方法将数组扩容至默认容量 10。之后每次添加元素时,如果当前数组已满,则会再次调用 `grow` 方法进行扩容。扩容规则为:首次扩容至 10,后续扩容至原数组长度的 1.5 倍或根据实际需求扩容。例如,当需要一次性添加 100 个元素时,会直接扩容至 110 而不是 15。
      331 4
      Java ArrayList扩容的原理
      |
      9月前
      |
      存储 缓存 安全
      Java 集合江湖:底层数据结构的大揭秘!
      小米是一位热爱技术分享的程序员,本文详细解析了Java面试中常见的List、Set、Map的区别。不仅介绍了它们的基本特性和实现类,还深入探讨了各自的使用场景和面试技巧,帮助读者更好地理解和应对相关问题。
      137 5
      |
      10月前
      |
      缓存 算法 Java
      本文聚焦于Java内存管理与调优,介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制
      在现代软件开发中,性能优化至关重要。本文聚焦于Java内存管理与调优,介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制。通过调整垃圾回收器参数、优化堆大小与布局、使用对象池和缓存技术,开发者可显著提升应用性能和稳定性。
      164 6
      |
      10月前
      |
      存储 Java 索引
      Java中的数据结构:ArrayList和LinkedList的比较
      【10月更文挑战第28天】在Java编程世界中,数据结构是构建复杂程序的基石。本文将深入探讨两种常用的数据结构:ArrayList和LinkedList,通过直观的比喻和实例分析,揭示它们各自的优势与局限,帮助你在面对不同的编程挑战时做出明智的选择。