黑马程序员Java教程学习笔记(二)

学习视频:https://www.bilibili.com/video/BV1Cv411372m
如侵权,请私信联系本人删除


黑马程序员Java学习笔记(二)

数组概述

  • 数组就是用来存储一批同种类型数据的内存区域(可以理解为容器)
int[] arr = {10, 20, 30, 40, 50, 60};
String[] names = {"张三", "李四", "王五"};

数组定义方式一、访问、注意事项

  • 静态初始化数组:定义数组的时候直接给数组赋值
//完整格式
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...};
double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
int[] ages = new int[]{12, 24, 36};

//简化格式
数据类型[] 数组名 = {元素1, 元素2, 元素3...};
int[] ages = {12, 24, 36};
public class ArrayDemo1 {
    public static void main(String[] args) {
        // double[] scores = new double[]{88.9, 65.8, 94.3};
        double[] scores = {88.9, 65.8, 94.3};
        // int[] ages = new int[]{19, 22, 21};
        int[] ages = {19, 22, 21};
        // String[] names = new String[]{"张三", "李四", "王五"};
        String[] names = {"张三", "李四", "王五"};

        System.out.println(scores);
        System.out.println(ages);
        System.out.println(names);
    }
}

/*
运行结果:
 [D@43a25848
 [I@3ac3fd8b
 [Ljava.lang.String;@5594a1b5
*/
  • [表示是数组格式
  • DILjava.lang.String;表示的是数据类型
  • 十六进制字符串则是标识数据在内存中的地址
    在这里插入图片描述
    特别注意:数组变量名中存储的是数组在内存中的地址,数组是引用类型

数组的访问

		int[] ages = {19, 22, 21};
        // 访问
        System.out.println(ages[0]);
        // 赋值
        ages[0] = 36;
        System.out.println(ages[0]);
        // 获取数组长度
        System.out.println(ages.length);
        // 访问数组最大索引
        System.out.println(ages[ages.length - 1]);

数组的几个注意事项

  • 数据类型[] 数组名也可以写成数据类型 数组名[]
  • 什么类型的数组必须存放什么类型的数据,否则报错
  • 数组一旦定义出来,程序执行的过程中,长度、类型就固定了

数组定义方式二,元素默认值规则

数组的动态初始化

  • 定义数组的时候只确定元素的类型和数组的长度,之后再存入具体数据
// 先定义
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];

// 后赋值
arr[0] = 10;
System.out.println(arr[0]);

动态数据中元素没有赋值,会有一个默认值,int类型为0double类型为0.0String类型为null
在这里插入图片描述

public class ArrayDemo1 {
    public static void main(String[] args) {
        double[] scores = new double[3];
        System.out.println(scores[0]);
        scores[0] = 99.9;
        System.out.println(scores[0]);
        String[] names = new String[3];
        names[0] = "mochu7";
        names[2] = "末初";
        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
    }
}
/*
运行结果:
0.0
99.9
mochu7
null
末初
*/

注意:静态初始化数组和动态初始化数组不可以混用,如下这样是会报错的

int[] arrs = new int[3]{1, 2, 3}

数组遍历、元素求和

public class ExampleCode {
    public static void main(String[] args) {
        double sum = 0;
        double[] scores = {67.2, 52.5, 89.9, 92.3, 74.6};
        for(int i=0; i<scores.length; i++){
            System.out.println(scores[i]);
            sum += scores[i];
        }
        System.out.println("总成绩为:" + sum);
    }
}
/*
运行结果为:
67.2
52.5
89.9
92.3
74.6
总成绩为:376.5
*/

数组案例:求最值、猜数字、随即排名、冒泡排序

求最大值

public class ExampleCode {
    public static void main(String[] args) {
        int[] faceScore = {15, 9000, 10000, 20000, 9500, -5};
        int max = faceScore[0];
        for(int i=0; i<faceScore.length; i++){
            if(max < faceScore[i]){
                max = faceScore[i];
            }
        }
        System.out.println("最大值:" + max);
    }
}
/*
运行结果:
最大值:20000
*/

猜数字游戏

package com.example.code;
import java.util.Random;
import java.util.Scanner;

public class ExampleCode {
    public static void main(String[] args) {
        Random rd = new Random();
        Scanner sc = new Scanner(System.in);
        int[] nums = new int[5];
        for(int i = 0; i < nums.length; i++) {
            nums[i] = rd.nextInt(20) + 1;
        }
        OUT:
        while(true) {
            System.out.println("请输入你猜的数字(1-20):");
            int guessNumber = sc.nextInt();
            for(int i = 0; i < nums.length; i++) {
                if(guessNumber == nums[i]) {
                    System.out.println("恭喜你!答对了,你猜的数字是:" + guessNumber);
                    break OUT; // 结束外循环
                }
            }
            System.out.println("当前猜测的数据,在数组中不存在,请重新猜测");
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }
    }
}
/*
运行结果:
请输入你猜的数字(1-20):
12
当前猜测的数据,在数组中不存在,请重新猜测
请输入你猜的数字(1-20):
6
当前猜测的数据,在数组中不存在,请重新猜测
请输入你猜的数字(1-20):
7
当前猜测的数据,在数组中不存在,请重新猜测
请输入你猜的数字(1-20):
14
当前猜测的数据,在数组中不存在,请重新猜测
请输入你猜的数字(1-20):
16
恭喜你!答对了,你猜的数字是:16
16	1	4	17	16	
*/

随机排名

package com.example.code;
import java.util.Random;
import java.util.Scanner;

public class ExampleCode {
    public static void main(String[] args) {
        int[] jobNumber = new int[5];
        Random rd = new Random();
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < jobNumber.length; i++) {
            System.out.println("请输入第" + (i + 1) + "员工的工号:");
            jobNumber[i] = sc.nextInt();
        }
        System.out.print("你输入的工号为:" + " ");
        for (int i = 0; i < jobNumber.length; i++) {
            System.out.print(jobNumber[i] + "\t");
        }
        for (int i = 0; i < jobNumber.length; i++) {
            int index = rd.nextInt(jobNumber.length);
            int temp = jobNumber[index];
            jobNumber[index] = jobNumber[i];
            jobNumber[i] = temp;
        }
        System.out.println("\n");
        for (int i = 0; i < jobNumber.length; i++) {
            System.out.print(jobNumber[i] + "\t");
        }
    }
}
/*
运行结果:
请输入第1员工的工号:
1234
请输入第2员工的工号:
7479
请输入第3员工的工号:
5117
请输入第4员工的工号:
9876
请输入第5员工的工号:
2469
你输入的工号为: 1234	7479	5117	9876	2469	

5117	2469	7479	9876	1234
*/

数组排序的技术

  • 冒泡排序
  • 选择跑徐
  • 插入排序

数组搜索相关的技术

  • 二分搜索
  • 分块查找
  • 哈希表查找
public class ExampleCode {
    public static void main(String[] args) {
        int[] arr = {2, 5, 3, 1};
        // 定义一个循环,控制比较轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // 定一个循环,控制每轮比较次数
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 判断j当前位置的元素值是否大于后一个位置,若大于则交换
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

数组内存图、常见使用问题

Java内存介绍:

  • 方法区
  • 本地方法栈
  • 寄存器

方法区:放Class文件的
栈内存:运行的方法、main方法、定义的变量
堆内存:对象

在这里插入图片描述
在这里插入图片描述

Debug工具使用

  • IDEA自带的断点调试(排错)工具,可以控制代码从断点开始一行一行的执行,然后详细观看程序执行的情况。

Debug工具基本使用步骤:

  1. 在需要控制的代码左侧,点击一下,形成断点
  2. 选择使用Debug方式启动程序,启动后程序会在断点暂停
  3. 控制代码一行一行的往下执行

在这里插入图片描述

多个断点直接的跳转如下,点击左侧的Resume Program

在这里插入图片描述

方法定义格式、常见问题

方法是一种语法结构,它可以把一段代码封装成一个功能,以方便重复调用,提高代码复用性。

public class Demo1 {
    public static void main(String[] args) {
        int res = sum(55, 45); // 调用方法
        System.out.println(res);
    }

    public static int sum(int a, int b) {
        int c = a + b;
        return c;
    }
}

方法定义的完整格式:

修饰符 返回值类型 方法名(形参列表) {
	方法体代码(需要执行的功能代码)
	return 返回值;
}

public static int sum(int a, int b) {
     int c = a + b;
     return c;
}

修饰符: public static
返回值类型:intdoubleStringvoid
方法名称:任意定义
形参列表:(参数1, 参数2)
返回值:return 需要返回的变量

调用格式:方法名(...)

方法格式的注意事项:

  • 方法声明了具体的返回值类型,内部必须使用return返回对应类型的数据
  • 形参列表可以有很多个,甚至可以没有;如果有多个形参必须用”,“隔开,且不能给初始化值
  • 如果方法不需要返回结果,返回值类型必须声明成void(),此时方法内部不可以使用return返回数据。
  • 方法的编写顺序无所谓(方法定义在调用位置的前后都可以)
  • 方法与方法之间是平行关系,不能嵌套定义
  • 方法的返回值类型为void(无返回值),方法内则不能使用return返回数据,如果方法的返回值类型写了具体类型,方法内部则必须使用return返回对应类型的数据。
  • return语句下面,不能编写代码,return之后的代码执行不到,属于无效代码
  • 方法不调用就不执行,调用时必须严格匹配方法的参数情况
  • 有返回值的方法调用时可以选择定义变量的接收结果,或者直接输出调用,甚至直接调用;无返回值方法的调用只能调用;

无参数无返回的方法

public class Demo1 {
    public static void main(String[] args) {
        print();
    }

    public static void print() {
        System.out.println("Hello,World");
        System.out.println("Hello,World");
        System.out.println("Hello,World");
    }
}

方法案例:求和、判断奇偶数、求最值

求和

public class Demo1 {
    public static void main(String[] args) {
        System.out.println("1-50的和:" + sum(50));
        System.out.println("1-100的和:" + sum(100));
    }

    public static int sum(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
}

判断奇偶数

public class Demo1 {
    public static void main(String[] args) {
        check(11);
        check(100);
    }

    public static void check(int n) {
        if (n % 2 == 0) {
            System.out.println(n + "是偶数");
        }else {
            System.out.println(n + "是奇数");
        }
    }
}

求最值

public class Demo1 {
    public static void main(String[] args) {
        int[] examScore = {78, 99, 123, 143, 98, 86, 112, 127, 65};
        int max = getArrayMaxNumber(examScore);
        System.out.println("数组最大值是:" + max);
    }

    public static int getArrayMaxNumber(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

方法的内存原理

方法的调用流程:

  • 方法没有被调用的时候,在方法区中的字节码文件中存放
  • 方法被调用的时候,需要进入到栈内存中运行

在这里插入图片描述

方法参数传递机制

值传递

  • 在传输实参给方法的形参的时候,并不是传输实参变量本身,而是传输实参变量中存储的值,这就是值传递
    – 实参:在方法内部定义的变量
    – 形参:在定义方法时,”()“ 中所声明的参数
public class Demo1 {
    public static void main(String[] args) {
        int a = 10;
        change(a);
        System.out.println(a); // 10
    }
    public static void change(int a) {
        System.out.println(a); // 10
        a = 20;
        System.out.println(a); // 20
    }
}

引用传递

public class Demo1 {
    public static void main(String[] args) {
        int[] arrs = {10, 20, 30};
        change(arrs);
        System.out.println(arrs[1]); // 222
    }
    public static void change(int[] arrs) {
        System.out.println(arrs[1]); // 20
        arrs[1] = 222;
        System.out.println(arrs[1]); // 222
    }
}

通过地址传递,直接修改了该地址上的值

在这里插入图片描述

  • 基本类型和引用类型的参数在传递的时候都是值传递
    – 基本类型的参数传输存储的数据值
    – 引用类型的参数传输存储的地址值

方法参数传递的案例

案例一:打印数组内容

public class Demo1 {
    public static void main(String[] args) {
        int[] ages = {10, 20, 30, 40};
        printArray(ages);
        int[] numbers = null;
        printArray(numbers);
        int[] numbers1 = {};
        printArray(numbers1);
    }
    public static void printArray(int[] arr) {
        System.out.print("[");
        if (arr != null && arr.length != 0) {
            for (int i = 0; i < arr.length; i++) {
                System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
            }
        }
        System.out.println("]");
    }
}

案例二:从数组中查询元素的索引返回

public class Demo1 {
    public static void main(String[] args) {
        // 从整型数组中查询某个索引返回,不存在返回-1
        int[] arr = {12, 24, 36, 41, 59};
        int index = searchIndex(arr, 40);
        System.out.println("您查询的数据索引是:" + index);
    }

    public static int searchIndex(int[] arr, int data) {
        for (int i = 0; i < arr.length; i++) {
            if (data == arr[i]) {
                return i;
            }
        }
        return -1;
    }
}

案例三:比较两个数组内容是否相同

public class Demo1 {
    public static void main(String[] args) {
        int[] arr1 = {10, 20, 30, 40, 50};
        int[] arr2 = {10, 20, 30, 41, 50};
        System.out.println(compareArray(arr1, arr2));
    }
    public static boolean compareArray(int[] arr1, int[] arr2) {
        if (arr1.length == arr2.length) {
            for (int i = 0; i < arr1.length; i++) {
                if(arr1[i] != arr2[i]) {
                    return false;
                }
            }
            return true;
        }else {
            return false;
        }
    }
}

方法重载、return关键字

方法重载:同一个类中,出现多个方法名称相同,但是形参列表是不同的,那么这些方法就是重载方法。

public class Demo1 {
    public static void main(String[] args) {
        fire();
        fire("岛国");
        fire("岛国", 100);
    }
    public static void fire() {
        System.out.println("默认发射一枚武器给米国");
    }
    public static void fire(String location) {
        System.out.println("默认发射一枚武器给" + location);
    }
    public static void fire(String location, int number) {
        System.out.println("默认发射" + number + "枚武器给" + location);
    }
}
  • 使用方法重载的好处:
    对于相似功能的业务场景:可读性好,方法名称相同提示是同一类型的功能,通过形参不同实现功能差异化的选择,这是一种专业的代码设计。

  • 方法重载的识别技巧:
    只要是同一个类中,方法名称相同,形参列表不同,那么他们就是重载的方法,其他的不管!(如:修饰符,返回值类型都无所谓)

形参列表不同指的是:形参的个数、类型、顺序不同,不关心形参的名称

return关键字的单独使用

return; 可以立即跳出并结束当前方法的执行;return关键字单独使用可以放在任何方法中。

public class Demo1 {
    public static void main(String[] args) {
        chu(10, 0);
    }

    public static void chu(int a, int b) {
        if (b == 0) {
            System.out.println("除数不能为0");
            return; //直接跳出当前方法
        }else {
         int c = a / b;
            System.out.println("结果是:" + c);
        }
    }
}

编程训练-案例1:买飞机票

在这里插入图片描述

package com.mochu.project1;
import java.util.Scanner;

public class BuyAirtTckets {
    public static void main(String[] args) {
        // 1、用户输入机票原价、月份、舱位类型
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入机票原价:");
        double price = sc.nextDouble();

        System.out.print("请输入月份(1-12):");
        int month = sc.nextInt();

        System.out.print("请输入舱位类型:");
        String cabin = sc.next();

        System.out.println("机票的价格是:" + calcPrice(price, month, cabin) + "¥");
    }

    // 定义方法接收信息,统计优惠后的价格返回
    public static double calcPrice(double price, int month, String cabin) {
        // 旺季5-10月,淡季11-12月、1-4月
        if (month >= 5 && month <= 10) {
            // 旺季
            switch (cabin) {
                case "头等舱":
                    price *= 0.9;
                    break;
                case "经济舱":
                    price *= 0.85;
                    break;
                default:
                    System.out.println("对不起,您输入的舱位类型有误~");
                    price = -1;
            }
        }else if (month == 11 || month == 12 || month >= 1 && month <= 4){
            // 淡季
            switch (cabin) {
                case "头等舱":
                    price *= 0.7;
                    break;
                case "经济舱":
                    price *= 0.65;
                    break;
                default:
                    System.out.println("对不起,您输入的舱位类型有误~");
                    price = -1;
            }
        }else {
            System.out.println("对不起,您输入的月份有误~");
            return -1;
        }
        return price;
    }
}

在这里插入图片描述

编程训练-案例2:找素数

判断101~200之间有多少个素数,并输出所有素数
素数:除了1和它本身以外,不能被其它正整数整除,这就叫素数

package com.mochu.project1;

public class SearchPrimeNumber {
    public static void main(String[] args) {
        // 定义一个循环,遍历101-200之间的全部数字
        for (int i = 101; i <= 200 ; i++) {
            // 判断遍历当前这个数是否是素数
            boolean flag = true;
            for (int j = 2; j < i / 2 ; j++) {
                if(i % j == 0) {
                    flag = false;
                    break;
                }
            }
            if(flag) {
                System.out.print(i + "\t");
            }
        }
    }
}

编程训练-案例3:验证码

package com.mochu.project1;
import java.util.Random;

public class CreateVerifCode {
    public static void main(String[] args) {
        String code = createVerifCode(5);
        System.out.println("验证码:" + code);
    }
    // 定义一个方法返回一个随机验证码,返回值类型为String,形参int n位数
    public static String createVerifCode(int n) {
        String verifcode = "";
        Random rd = new Random();
        for (int i = 0; i < n; i++) {
            int type = rd.nextInt(3);
            switch(type) {
                case 0:
                    // 大写字符(ASCII 65-90)
                    char ch = (char) (rd.nextInt(26) + 65);
                    verifcode += ch;
                    break;
                case 1:
                    // 小写字符(ASCII 97-122)
                    char ch1 = (char) (rd.nextInt(26) + 97);
                    verifcode += ch1;
                    break;
                case 2:
                    // 数字(ASCII 48-57)
                    int num = rd.nextInt(10);
                    verifcode += num;
                    break;
            }
        }
        return verifcode;
    }
}

在这里插入图片描述

编程训练-案例4:数组的复制

在这里插入图片描述

package com.mochu.project1;

public class ArrayCopy {
    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33, 44, 55};
        int[] arr2 = new int[arr1.length];
        arrayCopy(arr1, arr2);
        printArray(arr1);
        printArray(arr2);
    }

    public static void arrayCopy(int[] arr1, int[] arr2) {
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
    }

    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }
}

在这里插入图片描述

编程训练-案例5:评委打分

在这里插入图片描述

package com.mochu.project1;

import java.util.Scanner;

public class JudgeScore {
    public static void main(String[] args) {
        // 定义一个动态数组存储六位评委的分数
        int[] scores = new int[6];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            System.out.print("请输入第" + (i + 1) + "位评委的分数:");
            int score = sc.nextInt();
            scores[i] = score;
        }

        int max = scores[0];
        int min = scores[0];
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
            if(scores[i] > max) {
                max = scores[i];
            }
            if(scores[i] < min) {
                min = scores[i];
            }
            sum += scores[i];
        }
        double result = (sum - max - min) * 1.0 / (scores.length - 2);
        System.out.println("选手最终得分是:" + result);
    }
}

在这里插入图片描述

编程训练-案例6:数字加密

在这里插入图片描述

package com.mochu.project1;
import java.util.Scanner;

public class NumberEncrypt {
    public static void main(String[] args) {
        System.out.print("请输入需要加密的数字个数:");
        Scanner sc = new Scanner(System.in);
        int length = sc.nextInt();
        int[] arr = new int[length];
        // 录入数组元素
        for (int i = 0; i < arr.length; i++) {
            System.out.print("请输入第" + (i + 1) + "位数字:");
            int number = sc.nextInt();
            arr[i] = number;
        }
        printArray(arr); // 打印数组
        // 数字加密
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }
        // 数组反转(逆序)
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
        printArray(arr);
    }
    // 打印数组的方法
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }
}

在这里插入图片描述

编程训练-案例7:模拟双色球

在这里插入图片描述

package com.mochu.project1;
import java.util.Random;
import java.util.Scanner;


public class DoubleColorBall {
    public static void main(String[] args) {
        // 随机生成6个红球号码(1-33,不能重复),随机一个蓝球号码(1-16),采用数组将中奖号码封装起来。
        int[] lucknumbers = createLuckyNumber();
        // 用户输入七个双色球号码,作为用户选号
        int[] inputnumbers = userInputNumbers();

        judge(lucknumbers, inputnumbers);
    }
    // 判断中奖,判断红球、蓝球分别中了多少个数
    public static void judge(int[] lucknumbers, int[] inputnumbers){
        int redballcount = 0;
        int blueballcount = 0;
        // 统计红球中了多少个
        for (int i = 0; i < inputnumbers.length - 1; i++) {
            for (int j = 0; j < lucknumbers.length - 1; j++) {
                if(inputnumbers[i] == lucknumbers[j]) {
                    redballcount++;
                    break;
                }
            }
        }
        // 统计蓝球中了没中
        blueballcount = inputnumbers[inputnumbers.length - 1] == lucknumbers[lucknumbers.length - 1] ? 1 : 0;
        System.out.println("您的号码是:");
        printArray(inputnumbers);
        System.out.println("中奖号码是:");
        printArray(lucknumbers);
        System.out.println("您命中了" + redballcount + "个红球");
        System.out.println("您" + (blueballcount == 1 ? "命中了" : "没有命中") + "蓝球");
        // 判断奖励情况
        if(blueballcount == 1 && redballcount < 3) {
            System.out.println("恭喜您!,获得5元奖励~");
        }else if(blueballcount == 1 && redballcount == 3 || blueballcount == 0 && redballcount == 4) {
            System.out.println("恭喜您!获得10元奖励~");
        }else if(blueballcount == 1 && redballcount == 4 || blueballcount == 0 && redballcount == 5) {
            System.out.println("恭喜您!获得200元奖励~");
        }else if(blueballcount == 1 && redballcount == 5) {
            System.out.println("恭喜您!获得3000元奖励~");
        }else if(blueballcount == 0 && redballcount == 6) {
            System.out.println("恭喜您!获得500万奖励~");
        }else if(blueballcount == 1 && redballcount == 6) {
            System.out.println("恭喜您!获得1000万奖励~");
        }else {
            System.out.println("很遗憾,您没有获奖");
        }
    }
    // 录入用户生成号码
    public static int[] userInputNumbers() {
        int[] inputNumbers = new int[7];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < inputNumbers.length - 1; i++) {
            System.out.print("请输入第" + (i + 1) + "个红球号码(1-33,要求不重复):");
            inputNumbers[i] = sc.nextInt();
        }
        System.out.print("请输入篮球号码(1-16,要求不重复):");
        inputNumbers[inputNumbers.length - 1] = sc.nextInt();

        return inputNumbers;
    }

    // 生成中奖号码
    public static int[] createLuckyNumber() {
        int[] numbers = new int[7];
        // 6个不重复的红球号码(1-33)
        Random rd = new Random();
        for (int i = 0; i < numbers.length - 1; i++) {
            // 需要判断当前这个随即号码之前是否出现过,如果出现过则需要重新生成一个号码直到不重复为止。
            while (true) {
                int data = rd.nextInt(33) + 1;
                boolean flag = true;
                for (int j = 0; j < i; j++) {
                    if(numbers[j] == data) {
                        flag = false;
                        break;
                    }
                }
                if(flag) {
                    numbers[i] = data;
                    break;
                }
            }
        }
        // 生成蓝球号码(1-16)
        numbers[numbers.length - 1] = rd.nextInt(16) + 1;
        return numbers;
    }
    // 遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length -1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }
}

在这里插入图片描述

  • 7
    点赞
  • 46
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

末 初

谢谢老板!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值