＜训练营＞初学Java-Java基础知识-数组-扑克牌day04

已于 2022-04-26 09:46:44 修改
阅读量867 收藏 3
点赞数 1
CC 4.0 BY-SA版权
文章标签： java
于 2022-04-25 12:21:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/TheNewSystrm/article/details/124397482
这篇博客介绍了Java中的数组基础知识，包括数组的定义、声明、访问元素、初始化以及遍历。详细讲解了如何声明和访问数组元素，并展示了数组元素的默认值。此外，文章通过一个扑克牌案例，演示了如何初始化、洗牌和发牌，涉及随机数生成和变量交换技巧。最后，给出了完整的扑克牌案例代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1数组

1.1什么是数组

用于存储数据类型一致的一组数据。

使用一个变量操作一组数据。

1.2声明数组

语法：

数据类型[] 变量 = new 数据类型[]

列子：

int[] arr = new int[500];
double [] arr2 = new double[100];
String[] arr3 = new String[10];

1.3访问数组元素（Element）

数组中的每个数据称为元素，使用下标（index）访问数组中的元素

  • 下标范围 0 ~ 长度 -1]
  • 数组变量[下标]方式访问数组元素
  • 数组元素就是一个单一的变量

列子：

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 声明数组，访问数据元素
         */
        int[] arr = new int[5];
        //数组中有5个元素，序号为：0  1  2  3  4
        arr[0] = 5;
        arr[1] = 8;
        arr[2] = 10;
        arr[3] = 122;
        arr[4] = 889;
        System.out.println(arr[0]);//5
        arr[0]++;
        System.out.println(arr[0]);//6
        System.out.println(arr[0] + arr[1]);//14
    }
}

控制台展示：

 1.4数组元素的默认值

用长度创建数组的时候，数组元素有默认值：

  • 整数的时候是 0
  • 浮点数是 0.0
  • 布尔类型是 false
  • 字符类型 ：编码为0的字符
  • 引用类型，如String，默认值null

列子：

public class Demo02 {
    public static void main(String[] args) {
        /**
         * 测试元素的默认值
         */
        long[] arr1 = new long[10];
        System.out.println(arr1[0]);//0
        double[] arr2 = new double[8];
        System.out.println(arr2[2]);//0.0
        boolean[] arr3 = new boolean[8];
        System.out.println(arr3[3]);
        char[] chs = new char[7];
        System.out.println((int) chs[1]);//0
        String[] arr4 = new String[4];//{null,null,null,null}
        System.out.println(arr4[2]);//null
    }
}

控制台展示： 

1.5使用元素初始化数组

使用以知方法创建数组

语法：

数据类型[] 变量 = new 数据类型[]{元素,元素,元素...};
简写
数据类型[] 变量 = {元素,元素,元素...};

创建数组的时候，不能指定长度，自动按照元素量分配长度

列子：

public class Demo03 {
    public static void main(String[] args) {
        /**
         * 使用元素初始化数组
         */
        int[] arr1 = new int[]{1,2,22,13,41};
        int[] arr2 = {22,331,44,123,4442};
        double[] arr3 = {2.5,34.7,5.5};
        String[] names = {"Tom","Jack","Tony"};
        System.out.println(arr1[2]);//22
        System.out.println(arr2[3]);//123
        System.out.println(names[2]);//Tony;
    }
}

控制台展示：

 1.6遍历数组元素

利用循环,访问每个数组元素, 称为数组的遍历, 也称数组的迭代

数组中有只读属性 length 返回数组的长度, 也就是数组元素的个数

如果超范围访问数组下标, 将出现数组下标越界异常

原理：

public class Demo04 {
    public static void main(String[] args) {
        /**
         * 遍历数组的每个元素
         */
        int[] arr = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89};
        int sum = 0;
        System.out.println("数组的长度:"+arr.length);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            sum +=arr[i];
        }
        System.out.println("数组的总数:"+sum);
    }
}

控制台展示：

两种数组初始化的区别

  • 按照长度初始化：元素数量较多 或 不知道元素的情况下
  • 用元素初始化：元素不多，并且知道每个元素

2案例：扑克牌

2.1初始化一副扑克牌

  • 按照长度初始化一个数组,得到54个null
String[] cards = new String[54];
  • 找规律，利用算法初始化每个元素

(图解)：

代码展示： 

        /**
         * 扑克牌
         * 扑克牌中一共有54个元素'
         * 按照长度初始化元素；
         */        
        //定义一个String类型的数组用来存储54张扑克牌
        String[] cards = new String[54];
        //给cards数组的最后两位赋值为大王，小王
        cards[53] = "大王";
        cards[52] = "小王";
        //定义一个数组用来存储A,2,3,4 ... K
        String[] rank = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

        int length = 0;
        String[] RedBlack = {"红桃","方片","黑桃","梅花"};
        for (int i = 0; i < RedBlack.length; i++) {
            for (int j = 0; j < rank.length; j++) {
                cards[length] = RedBlack[i]+rank[j];
                length++;
            }
        }

        System.out.println("正常牌的顺序：");
        //查看所有扑克牌是否存起来了
        for (int i = 0; i < cards.length; i++) {
            System.out.print(cards[i]+" ");
            if ((i+1) % 13 == 0) {
                System.out.println();
            }
        }

控制台效果： 

2.2随机数Random

Java随机数API

  • java.util.Random，提供了丰富的API，丰富，使用更加方便
    • nextDouble();，产生0~1之间的随机数
    • nextInt(范围);，0范围之间的随机数
    • nextLong();
    • ...
  • java.long.Math，只提供了浮点数API，需要换算才能得到想要的数据
    • random()与Random nextDouble();功能相同，产生0~1之间的随机数

生成特定范围的随机数，生成 8 ~ 20 的随机数，不包含20

8 9 10 11 12 13 14 15 16 17 18 19

(图解) ：

代码演示：

import java.util.Random;

public class Demo08 {
    public static void main(String[] args) {
        /**
         * 生成特定范围的随机数，生成 8 ~ 20 的随机数，不包含20
         */
        Random random = new Random();
        int max = 20;
        int min = 8;
        int x = random.nextInt(max - min) + min;
        System.out.println(x);
    }
}

控制台展示：

 

2.3交换两个变量的值

将两个变量的值交换以下：

int a = 6;
int b = 8;
//交换运算，a中是8，b中是6
int t = a;
a = b;
b = t;

 (图解)：

2.4洗牌(打乱)

(图解)：

代码：

        System.out.println();
        //洗牌（打乱牌）
        Random random = new Random();
        for (int i = cards.length ; i > 0 ; i--){
            //获取一个随机数范围是从0~i的随机数
            //i每次循环减去1用来控制随机数的范围
            int index = random.nextInt(i);
            //拿到这个随机数进行位置交换
            String temp = cards[i-1];
            cards[i-1] = cards[index];
            cards[index] = temp;
        }

        System.out.println("将牌打乱以后的顺序");
        //测试扑克牌打乱顺序了吗
        for (int i = 0; i < cards.length; i++) {
            System.out.print(cards[i]+" ");
            if ((i+1) % 13 == 0) {
                System.out.println();
            }
        }
        System.out.println();

控制台展示：

2.5发牌

 代码：

        //定义一个int类型的变量用来控制发牌的顺序
        int num = 0;
        //定义三个String类型的数组，用来代表三个人
        String[] laoLiu = new String[17];
        String[] liSi = new String[17];
        String[] wangWu = new String[17];
        //通过循环进行发牌
        for (int i = 0; i < 51; i+= 3) {
            //老刘拿第i张牌
            laoLiu[num] = cards[i];
            //李四拿第i+1张牌
            liSi[num] = cards[i+1];
            //王五拿第i+1+1张牌
            wangWu[num] = cards[i + 1 + 1];
            //循环完毕让i+=3条过他们拿的这几张牌
            num++;
        }

        //循环遍历他们三个的牌
        System.out.println("老刘的牌:");
        for (int i = 0; i < laoLiu.length; i++) {
            System.out.print(laoLiu[i]+" ");
        }
        System.out.println();
        System.out.println("李四的牌:");
        for (int i = 0; i < liSi.length; i++) {
            System.out.print(liSi[i]+" ");
        }
        System.out.println();
        System.out.println("王五的牌");
        for (int i = 0; i < wangWu.length; i++) {
            System.out.print(wangWu[i]+" ");
        }

        System.out.println();
        System.out.println("底牌：");
        for (int i = cards.length-1 ; i > cards.length-4; i--) {
            System.out.print(cards[i]+" ");
        }

控制台展示：

Unicode Table 网址：https://unicode-table.com/en/sets/suits-of-the-cards/

上述网址是各种小图标的Unicod编码

2.6最终代码整合

import java.util.Random;

public class Demo06 {
    public static void main(String[] args) {
        /**
         * 扑克牌
         * 扑克牌中一共有54个元素'
         * 按照长度初始化元素；
         */
        //定义一个String类型的数组用来存储54张扑克牌
        String[] cards = new String[54];
        //给cards数组的最后两位赋值为大王，小王
        cards[53] = "大🃏";
        cards[52] = "小🃏";
        //定义一个数组用来存储A,2,3,4 ... K
        String[] rank = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

        int length = 0;
        String[] RedBlack = {"♥","♦","♠","♣"};
        for (int i = 0; i < RedBlack.length; i++) {
            for (int j = 0; j < rank.length; j++) {
                cards[length] = RedBlack[i]+rank[j];
                length++;
            }
        }

        System.out.println("正常牌的顺序：");
        //查看所有扑克牌是否存起来了
        for (int i = 0; i < cards.length; i++) {
            System.out.print(cards[i]+" ");
            if ((i+1) % 13 == 0) {
                System.out.println();
            }
        }

        System.out.println();
        //洗牌（打乱牌）
        Random random = new Random();
        for (int i = cards.length ; i > 0 ; i--){
            //获取一个随机数范围是从0~i的随机数
            //i每次循环减去1用来控制随机数的范围
            int index = random.nextInt(i);
            //拿到这个随机数进行位置交换
            String temp = cards[i-1];
            cards[i-1] = cards[index];
            cards[index] = temp;
        }

        System.out.println("将牌打乱以后的顺序");
        //测试扑克牌打乱顺序了吗
        for (int i = 0; i < cards.length; i++) {
            System.out.print(cards[i]+" ");
            if ((i+1) % 13 == 0) {
                System.out.println();
            }
        }
        System.out.println();
        //定义一个int类型的变量用来控制发牌的顺序
        int num = 0;
        //定义三个String类型的数组，用来代表三个人
        String[] laoLiu = new String[17];
        String[] liSi = new String[17];
        String[] wangWu = new String[17];
        //定义一个String类型的数组存储底牌
        String[] base = new String[3];
        //通过循环进行发牌
        for (int i = 0; i < 51; i+= 3) {
            //老刘拿第i张牌
            laoLiu[num] = cards[i];
            //李四拿第i+1张牌
            liSi[num] = cards[i+1];
            //王五拿第i+1+1张牌
            wangWu[num] = cards[i + 1 + 1];
            //循环完毕让i+=3条过他们拿的这几张牌
            num++;
        }

        //循环遍历他们三个的牌
        System.out.println("老刘的牌:");
        for (int i = 0; i < laoLiu.length; i++) {
            System.out.print(laoLiu[i]+" ");
        }
        System.out.println();
        System.out.println("李四的牌:");
        for (int i = 0; i < liSi.length; i++) {
            System.out.print(liSi[i]+" ");
        }
        System.out.println();
        System.out.println("王五的牌");
        for (int i = 0; i < wangWu.length; i++) {
            System.out.print(wangWu[i]+" ");
        }

        System.out.println();
        System.out.println("底牌：");
        for (int i = 0 ; i < base.length; i++) {
            base[i] = cards[cards.length-1-i];
            System.out.print(base[i]+" ");
        }

    }
}

 控制台展示(最终效果)：

 

 上述这段代码看起来是不是非常乱，后面会整合的，不要着急

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值