JavaBase04 - 数组

最新推荐文章于 2025-04-04 19:00:02 发布

ggk911

最新推荐文章于 2025-04-04 19:00:02 发布

阅读量123

点赞数

文章标签： java 数据结构算法

本文链接：https://blog.youkuaiyun.com/ggk911/article/details/127853557

版权

本文详细介绍了Java中的数组概念、定义与初始化，包括动态和静态赋值方式。讲解了如何读取数组元素，以及使用增强for循环操作数组。还展示了冒泡排序算法，并提到了Java的Arrays工具类及其常用方法。此外，文章通过实例演示了生成随机数、实现猜数游戏、石头剪刀布游戏以及模拟双色球开奖的代码实现。

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

数组

概念

一组类型相同的数据的有序集合。

关于数组

实际在内存中是一块连续的空间。是保存数据的区域

数组定义是需要确定大小和数据类型，不可改变

定义数组是的变量保存的是实际内存空间的地址。

实际中保存的数据称为元素，每个元素有一个唯一的位置，称为索引（下标）从0开始。

可以通过数组的索引给数组赋值或读取数组中某个索引的值。

定义数组

数据类型[] 数组名 =new 数据类型[数组大小];

数组初始化

语法：数组名 = new 数据类型[数据大小];

数据类型[] 数组名 =new 数据类型[]{元素1，元素2，元素3、、、};

数据类型[] 数组名 ={元素1，元素2，元素3.。。。};

//定义一个保存数组的变量nameList
String[] nameList;
//在内存中申请一块连续空间，将这个空间的地址板寸到变量nameList中		
nameList = new String[10];

定义数组的同时初始化

语法：数据类型[] = new 数据类型[数据大小];

double[] = new double[10];

给数据赋值

动态赋值

int[] list = new int[10];
list[0]=123;
list[1]=123;
list[2]=123;

静态赋值

注意

数组一但初始化后，数组大小不能该v，其中的元素类型要统一
数组的索引范围是[0，大小-1]，使用时不能超出范围。在编译时无法识别的是否超出，但运行时会抛出“数组索引溢出”异常
数组一但初始化后，如果没有赋值，默认有初始值
数组可以通过“数组名.length()”获取长度

数组数据类型	默认值
String 引用类型	null
Int 整型	0
boolean	false
char 字符	空白字符
float 浮点	0.0

读取数组中的元素

通过"数组名[索引]"来读取元素

String[] nameList={"王海","刘涛","赵敏"};
System.out.println(nameList[0]);
System.out.println(nameList[1]);
System.out.println(nameList[2]);

可以通过循环给数组赋值和读取元素

//定义一个数组保存同学的姓名，循环接收后打印所有。
Scanner sc = new Scanner(System.in);
//定义数组
String[] stuName = new String[3];
//循环赋值
for (int i = 0; i < 3; i++) {
System.out.println("请输入第"+(i+1)+"位同学的姓名");
stuName[i] = sc.next();
}
//循环读取
System.out.println("当前学生列表");
for (int i = 0; i < stuName.length; i++) {//通过“数组名.length”获取数组的长度
System.out.print(stuName[i]+"\t");
}
//增强for循环 for(数据类型 变量名 : 数组或集合){}
for (String name : stuName) {
System.out.print(name + "\t");
}
System.out.println()

增强for循环

专门用于遍历数组或集合元素的一种循环语法：for(数据类型变量名 : 数组名){}

String[] list = {"admin","qwe","aaa"};
//使用增强for循环遍历
for(String name : list){
System.out.println(name);
}

冒泡排序

数组中每相邻的两个元素进行比较，如果不满足排序的规则，交换位置。

int[] num = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
        //长度-1轮
        for (int i = 0; i < num.length - 1; i++) {
            //一轮交换12次
            for (int i1 = 0; i1 < num.length - 1; i1++) {
                //交换
                int tem = 0;
                if (num[i1] > num[i1 + 1]) {
                    tem = num[i1 + 1];
                    num[i1 + 1] = num[i1];
                    num[i1] = tem;
                }
            }
            //输出
            System.out.print((i + 1) + "轮");
            for (int a : num) {
                System.out.print(a + " ");
            }
            //每轮换行
            System.out.println();
        }

数组工具类Arrays

Arrays是jdk提供的用于处理数组的工具类。包含了如排序、复制、填充等方法，这些方法都是静态方法，直接通过Arrays调用。

常用方法	作业
sort（数组）	将输入中的元素升序排序。
sort（数组，起始位置，结束位置）	对数组中[起始位置，结束卫视）区间的元素升序排序
fill（数组，值）	使用指定值对数组中的所有元素进行填充。
fill（数组，起始位置，结束位置）	使用指定值对数组中[起始位置，结束位置)区间的元素进行填充。
copyOf（数组，新数组长度）	赋值数组并指定复制后的数组的长度。得到复制后的新数组。
asList（一组数据）	减一组数据装换为List集合。
equals（数组1，数组2）	判断两个数字是否相同，得到判断的布尔值。一模一样才得true。

作业

生成随机数的方法

Random rd = new random();
//生成[0,num)范围内的随机int数
int res=rd.nextInt(int num);

实现猜数游戏

选择难度：简单[1,100]，困难：[1,1000]，地狱：[1,10000]，生成指定范围内的一个数

进行猜数，如果正确游戏结束，如果错误，继续猜并告知猜大了还是小了

根据猜对时所用的次数输出中几等奖

		Scanner s = new Scanner(System.in);
        System.out.println("你想和我玩个游戏吗？？？？？？？？？？？？？？？？？？\nYES or NO");
        if (s.next().toUpperCase().equals("YES")) {
            boolean flag = true;
            System.out.print("欢迎来到幸运儿的游戏！！你会有三个选择：\n1.噩梦：你将在1 ~ 9999999中选择\n2.普通：你将在1 ~ 9999中选择\n3.简单：你将在1 ~ 99中选择\n请做出你的选择：");
            //模式
            int mode = 0;
            //范围
            int end = 1;
            //次数
            int times = 0;
            switch (s.nextInt()) {
                case 1:
                    end = 9999999;
                    break;
                case 2:
                    end = 9999;
                    break;
                case 3:
                    end = 99;
                    break;
                default:
                    flag = false;
                    System.out.println("看来你是不想玩这个游戏！！！");
                    break;
            }
            while (flag) {
                //随机数生成
                Random rd = new Random();
                int suijis = rd.nextInt(end) + 1;
                //System.out.println(suijis + "test");
                //重复玩循环
                boolean flag1 = true;
                while (flag1) {
                    System.out.print("那唯一的数字是？？--");
                    //猜数字
                    int a = s.nextInt();
                    //次数
                    times++;
                    if (a == suijis) flag1 = false;
                    else if (a > suijis) System.out.println("大了");
                    else if (a < suijis) System.out.println("小了");
                }
                if (times == 1) System.out.println(times + "次！你就是天选！");
                else if (times > 1 && times <= 3) System.out.println(times + "次！这就是命中注定！");
                else if (times > 3 && times <= 6) System.out.println(times + "次！平庸之辈！");
                else if (times > 6 && times <= 10) System.out.println(times + "次！下下之选！");
                else  System.out.println(times + "次！你玷污了我的游戏！");
                System.out.println("再来一次？？");
                if (s.next().toUpperCase().equals("YES")) flag = true;
                else {
                    System.out.println("那实在是太可惜了！！！！！！！！！！！！！！！");
                    flag = false;
                }
            }
        } else {
            System.out.println("那实在是太可惜了！！！！！！！！！！！！！！！");
        }

在这里插入图片描述

实现石头剪刀布游戏

用1-2-3表示石头-剪刀-布

用户每次输入一个数，电脑每次自动生成一个数，根据游戏规则判断输赢

三局两胜

		Scanner s = new Scanner(System.in);
        System.out.println("石头剪刀布！听过起来很简单对吧！你有三次机会！？");

        Random rd = new Random();
        String[] arr = {"石头", "剪刀", "布", "输了", "赢了", "平局"};
        boolean flag1 = true;
        while (flag1) {
            boolean flag = true;
            //次数
            int a = 0;
            //赢得次数
            int c = 0;
            //平局次数
            int d = 0;
            //重复玩
            System.out.println("1.石头\n2.剪刀\n3.布");
            while (flag) {
                if (a > 2) break;
                //随机
                int suiji = rd.nextInt(3);
                int suiji1 = rd.nextInt(3);
                System.out.print("第" + (a + 1) + "把，我出的是" + arr[suiji1] + "你呢？！你的选择是？：");
                //输入
                int shuru = s.nextInt();
                a += 1;
                switch (shuru) {
                    //你出石头
                    case 1:
                        //判断
                        switch (suiji) {
                            //随机石头
                            case 0:
                                System.out.println(arr[5]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                d++;
                                break;
                            //随机剪刀
                            case 1:
                                System.out.println("你" + arr[4]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                c++;
                                break;
                            //随机布
                            case 2:
                                System.out.println("你" + arr[3]);
                                if (suiji != suiji1) System.out.println("骗到你了！！我出的是" + arr[suiji]);
                                break;
                        }
                        break;
                    //你出剪刀
                    case 2:
                        switch (suiji) {
                            //随机剪刀
                            case 1:
                                System.out.println(arr[5]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                d++;
                                break;
                            //随机布
                            case 2:
                                System.out.println("你" + arr[4]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                c++;
                                break;
                            //随机石头
                            case 0:
                                System.out.println("你" + arr[3]);
                                if (suiji != suiji1) System.out.println("骗到你了！！我出的是" + arr[suiji]);
                                break;
                        }
                        break;
                    //你出布
                    case 3:
                        switch (suiji) {
                            //随机石头
                            case 2:
                                System.out.println(arr[5]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                d++;
                                break;
                            //随机剪刀
                            case 0:
                                System.out.println("你" + arr[4]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                c++;
                                break;
                            //随机布
                            case 1:
                                System.out.println("你" + arr[3]);
                                if (suiji != suiji1) System.out.println("骗到你了！！我出的是" + arr[suiji]);
                                break;
                        }
                        break;
                    default:
                        System.out.println("再给你一次机会！");
                        flag = false;
                        break;
                }


            }
            if (c == 2 || c == 3 || c == 1 && d == 2) System.out.println("这局是你赢了！");
            else if (c == 1 && d == 1 || d == 3) System.out.println("我们打平了！");
            else System.out.println("你输掉了这局");
            System.out.println("再玩Y/N？");
            if (s.next().toUpperCase().equals("Y")) flag1 = true;
            else flag1 = false;
        }

在这里插入图片描述

模拟双色球开奖购买

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hWqEd3M0-1668424871013)(C:\Users\ggk-9\AppData\Roaming\Typora\typora-user-images\image-20221111193550474.png)]

//xuanze:选择的模式手动和机选 kaijiangsleeptime：选择后多久开奖suijisseqiusleeptime：开奖显示速度

public static int[] abc(int xuanze, int kaijiangsleeptime, int suijisseqiusleeptimetime) throws InterruptedException {
        int[] tongji = new int[7];
        System.out.print("\n====================================\n1.自选\n2.机选\n选择：\n");
        Scanner s = new Scanner(System.in);
        Scanner s1 = new Scanner(System.in);
        //自选或机选
        int xz = 0;
        //控制台输入
        //xz = s.nextInt();
        xz = xuanze;//机选测试
        //选择后的数组
        int[] xuanzeseqiu = new int[7];
        if (xz == 1) {
            //自选数组
            int[] zxseqiu = new int[7];
            //只装6位
            for (int i = 0; i < zxseqiu.length - 1; i++) {
                System.out.println("选择" + (i + 1) + "第个红球：");
                //装入
                zxseqiu[i] = s.nextInt();
                //大于31，小于1
                if (zxseqiu[i] > 31 || zxseqiu[i] < 1) i--;
                //重复
                for (int j = 0; j < i; j++) {
                    if (zxseqiu[i] == zxseqiu[j]) i--;
                }
            }
            int lanqiu = 0;
            System.out.println("选择蓝球：");
            lanqiu = s.nextInt();
            while (lanqiu < 1 || lanqiu > 16) {
                System.out.println("蓝球有误！\n选择蓝球：");
                lanqiu = s.nextInt();
            }
            zxseqiu[6] = lanqiu;
            //自选色球传给选择后的数组
            xuanzeseqiu = zxseqiu;
            System.out.println("您自选的号码如下：");
            showseqiu(zxseqiu, 0);
        } else if (xz == 2) {
            //机选
            int[] jxseqiu = new int[7];
            jxseqiu = seqiu();
            //机选色球传给选择后的数组
            xuanzeseqiu = jxseqiu;
            showseqiu(jxseqiu, 0);
        } else {
            System.out.println("ERROR");
        }
        System.out.println("\n！！！！！！即将开奖！！！！！！");
        Thread.sleep(kaijiangsleeptime);
        //随机色球
        int[] kaijiang = seqiu();
        showseqiu(kaijiang, suijisseqiusleeptimetime);
        //红球中的位数
        int red = 0;
        //中奖信息
        String info = "";
        //那外层for一个一个跟内层for比较（6位red），红球中的位数++
        for (int i = 0; i < xuanzeseqiu.length - 1; i++) {
            for (int i1 = 0; i1 < kaijiang.length - 1; i1++) {
                if (xuanzeseqiu[i] == kaijiang[i1]) red++;
            }
        }
        //判断
        //中了蓝球
        if (xuanzeseqiu[6] == kaijiang[6]) {
            switch (red) {
                case 0:
                case 1:
                case 2:
                    info = "六等奖";
                    tongji[6]++;
                    break;
                case 3:
                    info = "五等奖";
                    tongji[5]++;
                    break;
                case 4:
                    info = "四等奖";
                    tongji[4]++;
                    break;
                case 5:
                    info = "三等奖";
                    tongji[3]++;
                    break;
                case 6:
                    info = "一等奖";
                    tongji[1]++;
                    break;
            }
        } else { //没中蓝球
            switch (red) {
                default:
                    info = "倒霉蛋就是你！";
                    tongji[0]++;
                    break;
                case 4:
                    info = "五等奖";
                    tongji[5]++;
                    break;
                case 5:
                    info = "四等奖";
                    tongji[4]++;
                    break;
                case 6:
                    info = "二等奖";
                    tongji[2]++;
                    break;
            }
        }
        System.out.println("\n" + info);
        for (int i : tongji) {
            System.out.print(i + " ");
        }
        return tongji;
    }
//生成双色球数组
public static int[] seqiu() {
        int[] qiu = new int[7];
        Random rd = new Random();
        qiu[6] = rd.nextInt(15) + 1;
        //外层输入数组
        for (int i = 0; i < qiu.length - 1; i++) {
            //装进去
            qiu[i] = rd.nextInt(30) + 1;
            //循环检测在i之前的数是否重复，j从索引0开始一直到i索引，如果重复，此次输入作废
            for (int j = 0; j < i; j++) {
                if (qiu[i] == qiu[j]) i--;
            }
        }
        return qiu;
    }
//显示
 public static void showseqiu(int[] qiu, int showsudo) throws InterruptedException {
        for (int i = 0; i < qiu.length; i++) {
            if (i == 0) {
                Thread.sleep(showsudo);
                System.out.print("红球号码：");
            }
            if (i == 6) {
                System.out.print("\n蓝球号码：");
            }
            Thread.sleep(showsudo);
            System.out.print(qiu[i] + " ");

        }
    }

在这里插入图片描述

//统计100次
int[] a = new int[7];
        int[] b = new int[7];
        for (int i = 0; i < 100; i++) {
            a = abc(2, 0, 0);
            for (int j = 0; j < 7; j++) {
                b[j]+=a[j];
            }
        }
        System.out.println("\n====================================");
        for (int i : b) {
            System.out.print(i + " ");
        }