java中关于数组的一些案例
目录
数组案例：
1.猜数字游戏
需求：
开发一个幸运小游戏，游戏规则如下：
游戏后台随机生成1-20之间的5个数（无所谓是否重复），然后让大家来猜数字：
- 未猜中提示：“未命名"并继续猜测
- 猜中提示："运气不错，猜中了",并输出该数据第一次出现的位置，且输出全部5个数据，最终结束本游戏。
分析
- 随机生成5个1-20之间的随机数存储起来--->使用数组
- 定义一个死循环，输入数据猜测，遍历数组，判断数据是否在数组中，如果在，进行对应提示并结束死循环；如果没有猜中，提示继续猜测直到猜中为止。
package test.Demo01;
import java.util.Random;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//需求：5个1-20之间的随机数 ，让用户猜测，还要输出该数据在数组中第一次出现的索引，并打印数组内容出来
//没有猜中继续
//1.定义一个动态初始化的数组存储5个随机1-20之间的数据
int[] data = new int[5];
//2.动态生成5个1-20随机数,并存到数组中去
Random r = new Random();
for (int i = 0; i < 5; i++) {
data[i] = r.nextInt(20) + 1;
}
Scanner sc = new Scanner(System.in);
//3.使用一个死循环让用户进行猜测
OUT:
while (true) {
System.out.println("请你输入一个1-20的整数：");
int guessNumber = sc.nextInt();
for (int i = 0; i < data.length; i++) {
if (guessNumber == data[i]) {
System.out.println("恭喜你,猜对了！你猜中的数据索引是：" + i);
break OUT;
}
}
System.out.println("你猜的数字不正确,请重新猜");
}
//输出数组的全部元素让用户看到
for (int i = 0; i < data.length; i++) {
System.out.print(data[i]+"\t");
}
}
}
output:
请你输入一个1-20的整数：
5
你猜的数字不正确,请重新猜
请你输入一个1-20的整数：
1
恭喜你,猜对了！你猜中的数据索引是：3
2 15 15 1 18
2.随机排名
需求
某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。
请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
分析
- 在程序中录入5名员工的工号存储起来 --->使用数组。
- 依次遍历数组中的每个元素，随机一个索引数据，让当前的元素与该索引处的元素位置进行交换
package test.Demo01;
import java.util.Random;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
//键盘录入一组工号，最终要随机输出一组出来作为排名
//先动态初始化一个数组来存储5个工号
int[] codes = new int[5];
//2.定义一个循环，循环5次，一次录入一个工号存入对应的位置
Scanner sc = new Scanner(System.in);
for (int i = 0; i < codes.length; i++) {
System.out.println("请输入第"+(i+1)+"个员工工号：");
int code = sc.nextInt();
//存入到数组中去
codes[i] = code;
}
//遍历数组随机一个索引数据，让让前的元素与随机的索引位置处元素交换位置
Random r = new Random();
for (int i = 0; i < codes.length; i++) {
int index = r.nextInt(codes.length);
//定义一个临时变量来用作交换
int temp = codes[index];//随机索引处的工号
codes[index] = codes[i];
codes[i] = temp;
//交换完成
}
//遍历数组，打印数组的每个元素
for (int i = 0; i < codes.length; i++) {
System.out.print(codes[i] + "\t");
}
}
}
output:
请输入第1个员工工号：
12
请输入第2个员工工号：
52
请输入第3个员工工号：
33
请输入第4个员工工号：
5
请输入第5个员工工号：
123
5 123 33 52 12
3.冒泡排序
- 冒泡排序 的思想
- 从头开始两两比较，把较大的元素与较小的元素进行互换
- 每轮把当前最大的一个元素存入到数组当前的末尾。
- ，冒泡排序的实现步骤
- 定义一个外部循环控制总共需要冒几轮（数组的长度-1）
- 定义一个内部循环，控制每轮依次往后比较几个位置（数组的长度 - i -1）。
- 如果当前位置元素值 > 后一个位置的元素值，两者交换
package test.Demo01;
public class Test3 {
public static void main(String[] args) {
//1.定义一个数组，存储一组数据
int[] arr = {5, 2, 3, 1};
// 0 1 2 3
//2.定义一个循环控制比较轮数
for (int i = 0; i < arr.length - 1; i++) {
// i = 0 比较的次数3 j = 0 1 2
// i = 1 比较的次数2 j = 0 1
// i = 2 比较的次数1 j = 0
//3.定义一个循环控制每轮比较的次数，占位
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");
}
}
}
output:
1 2 3 5
4.买飞机票
- 机票价格按照淡旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱
- 按照如下规则计算机票价格：旺季（5 - 10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折
package test.Demo01;
import java.util.Scanner;
public class Test4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入机票原价：");
double price = sc.nextDouble();
System.out.println("请输入月份：");
int month = sc.nextInt();
System.out.println("请输入是头等舱还是经济舱：");
String seet = sc.next();
double money = calc(price, month, seet);
System.out.println("你最终的价格为：" + money);
}
public static double calc(double price, int month, String seet) {
//判断淡季或者旺季
if (month >= 5 && month <= 10) {
//旺季
switch (seet) {
case "头等舱":
price *= 0.9;
break;
case "经济舱":
price *= 0.85;
default:
System.out.println("您输入的仓位不正确！");
price = -1;//当前无法计算价格
}
} else if (month >= 11 || month <= 12 || month >= 1 && month <= 4) {
//淡季
switch (seet) {
case "头等舱":
price *= 0.7;
break;
case "经济舱":
price *= 0.65;
default:
System.out.println("您输入的仓位不正确！");
price = -1;//当前无法计算价格
}
} else {
System.out.println("您输入的月份有问题！");
price = -1;
}
return price;
}
}
output:
请输入机票原价：
1000
请输入月份：
5
请输入是头等舱还是经济舱：
头等舱
你最终的价格为：900.0
5.找素数
- 需求：找出101-200之间的素数并输出
- 素数是什么，除了1和他本身意外，不能被其他正整数除
package test.Demo01;
/**
* 需求：找出101-200之间的素数并输出
* 素数是什么，除了1和他本身意外，不能被其他正整数除
*/
public class Test5 {
public static void main(String[] args) {
//1.定义一个循环，找到101-200之间的全部整数
for (int i = 101; i <= 200; i++) {
// i = 101 102 103 ...200
//信号位：标记
boolean flag = true;//一开始认为当前数据是true
//2.判断当前遍历的这个数是否是素数
for (int j = 2; j < i / 2; j++) {
if (i % j == 0) {
flag = false;
break;
}
}
//3.根据判断的结果选择是否输出这个数，是素数则输出
if (flag == true) {
System.out.print(i + "\t");
}
}
}
}
output:
101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
6.开发验证码
需求
- 定义方法实现随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母。
分析
- 定义一个方法，生成验证码返回，方法参数是位数、方法返回值类型是String
- 在方法内部使用for循环生成指定位数的随机字符，并连接起来
- 把连接好的随机字符作为一组验证码并返回
package test.Demo01;
import java.util.Random;
/**
* 需求：定义方法实现随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母。
*/
public class Test6 {
public static void main(String[] args) {
//调用验证码获取一个随机验证码
String code = createCode(5);
System.out.println("此次的随机验证码为" + code);
}
public static String createCode(int n) {
Random r = new Random();
//3.定义一个字符串变量记录生成的随机字符
String code = "";
//2.定义一个for循环，循环n次,依次生成随机字符
for (int i = 0; i < n; i++) {
//3.生成一个随机字符：英文大写、小写、数字（0 1 2 ）
int type = r.nextInt(3);//0 1 2
switch (type) {
case 0:
//大写字母（A 65 -Z 65+25） （0-25）+65
char ch = (char) (r.nextInt(26) + 65);
code += ch;
break;
case 1:
//小写字母(a 97 z 97+25) (0-25)+97
char ch1 = (char) (r.nextInt(26) + 97);
code += ch1;
break;
case 2:
//数字字符
code += r.nextInt(10);//0-9中随机
break;
}
}
return code;
}
}
output:
此次的随机验证码为35aJk
7.数组元素复制
需求
- 把一个数组中的元素复制到另一个新数组中去
分析：
- 需要动态初始化一个数组，长度与原数组长度一致
- 遍历数组中的每个元素，依次赋值给新数组
- 输出两个数组的内容
package test.Demo01;
public class Test7 {
public static void main(String[] args) {
//1.定义一个数组并静态初始化
int[] arr1 = {12, 13, 32, 55, 22};
//2.定义一个与第一个数组长度一样的数组
int[] arr2 = new int[arr1.length];
//3.独立写一个数组复制 的方法
copy(arr1, arr2);
//4.打印两个数组
printArray(arr1);
printArray(arr2);
}
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("]");
}
private static void copy(int[] arr1, int[] arr2) {
//遍历数组1中的每个元素并赋值给数组2
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
}
}
output:
[12,13,32,55,22]
[12,13,32,55,22]
8.评委打分案例
需求
在唱歌比赛中，有6名评委给选手打分，分数的范围是[0-100]之间的整数。选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分
分析
- 把6个评委的分数录入到程序中去----》使用数组
- 遍历数组中每个数据，进行累加求和，并找出最高分，最低分
- 按照分数的计算规则算出平均分
package test.Demo01;
import java.util.Scanner;
public class Test8 {
public static void main(String[] args) {
int[] arr = new int[6];
Scanner sc = new Scanner(System.in);
int max = arr[0];
int min = arr[0];
int sum = 0;
//遍历数组将键盘录入的分数存到数组中
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第" + (i + 1) + "个分数：");
arr[i] = sc.nextInt();
}
//遍历数组中每个数据，进行累加求和，并找出最高分，最低分
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
if (min > arr[i]) {
min = arr[i];
}
sum += arr[i];
}
double avg = (sum - max - min) / (arr.length - 2);
System.out.println("选手的得分是："+avg);
}
}
output:
请输入第1个分数：
90
请输入第2个分数：
90
请输入第3个分数：
90
请输入第4个分数：
100
请输入第5个分数：
100
请输入第6个分数：
100
选手的得分是：95
9.数字加密
需求
- 某系统的数字密码，比如1983，采用加密的方式进行传输，规则如下:先得到每位数，然后每位数都加上5，再对10取余，最后将所有数字反转，得到一串新数。
分析
- 将每位数存入到数组中去，遍历数组的每位数据按照规则进行更改，把更改后的数据重新存入到数组中
- 将数组的前后元素进行交换，数组的最终元素就是加密后的结果。
package test.Demo01;
public class Test9 {
public static void main(String[] args) {
//定义一个数组来存储加密数据
int[] arr = {1, 9, 8, 3};
//遍历数组元素进行相关操作
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;
}
//遍历数组中的每个元素即可
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
}
}
}
output:
8346
10.双色球系统
1.业务分析、随机生成一组中奖号码
- 中奖号码由6个红球和1个篮球组成(注意：6个红球要求不能重复)
- 可以定义方法用于返回一组中奖号码(7个数据)，返回的形式是一个整形数组
public static int[] creatLuckNumber() {
//a.定义一个动态初始化的数组存储7个数字
int[] numbers = new int[7];
//b.遍历数组，为每个位置生成对应的数组,遍历6个位置生成6个不重复的红球号码1-33
Random r = new Random();
for (int i = 0; i < numbers.length - 1; i++) {
while (true) {
int data = r.nextInt(33) + 1;//(1-33)--->(0-32)+1
//c.注意：必须判断当前这个随机数之前有没有出现过，若出现过需要重新再生成一个，知道不重复位置
//定义一个flag标记为，默认data是没有出现过的
boolean flag = true;
for (int j = 0; j < i; j++) {
if (numbers[j] == data) {
//说明data这个随机数之前出现过
flag = false;
break;
}
}
if (flag) {
//说明data之前没有出现过
numbers[i] = data;
break;
}
}
}
//为第7个位置生成一个1-16的篮球号码。
numbers[numbers.length-1] = r.nextInt(16)+1;
return numbers;
}
2.用户输入一组双色球号码
分析
- 定义一个方法，该方法可以录入用户输入的6个红球和一个篮球
- 该方法最终返回一个数组，数组中就是用户录入的号码(7位)。
public static int[] userInputNumbers(){
//a.定义一个数组存储7个号码
int[] numbers = new int[7];
//b.让用户录入6个红球号码
Scanner sc = new Scanner(System.in);
for (int i = 0; i <numbers.length-1 ; i++) {
System.out.println("请你输入第"+(i+1)+"个红球号码（(1-33),不重复）：");
int data = sc.nextInt();
//c.把当前录入的数据存入到数组中去
numbers[i] = data;
}
//d.单独录入一个蓝球号码
System.out.println("请输入篮球号码（1-16）：");
numbers[numbers.length-1] = sc.nextInt();
return numbers;
}
中奖情况的分析判断
- 定义一个方法，可以接受中奖号码的数组，用户选号的数组
- 根据命中红球数和篮球数判断最终的中奖情况并输出详情和中奖金额、
public static void judge(int[] luckNumbers, int[] userNumbers) {
//判断是否中奖了
//1.定义两个变量分别表示红球命中的数量，和篮球命中的数量
int redHitNumber = 0;
int blueHitNumber = 0;
//2.判断红球命中了几个，
for (int i = 0; i < userNumbers.length - 1; i++) {
for (int j = 0; j < luckNumbers.length - 1; j++) {
//每次找到了相等的，意味着当前号码命中
if (userNumbers[i] == luckNumbers[j]) {
redHitNumber++;
break;
}
}
}
//判断篮球号码是否命中
// if (userNumbers[userNumbers.length-1]==luckNumbers[luckNumbers.length-1]){
// blueHitNumber++;
// }
blueHitNumber = userNumbers[userNumbers.length - 1]
== luckNumbers[luckNumbers.length - 1] ? 1 : 0;
System.out.println("官方中奖号码是：");
printArray(luckNumbers);
System.out.println("你投注号码是：");
printArray(userNumbers);
System.out.println("您命中了" + redHitNumber + "个红球");
System.out.println("您是否命中了蓝球：" + (blueHitNumber == 1 ? "是" : "否"));
//真正判断中奖情况|
if (blueHitNumber == 1 && redHitNumber < 3) {
System.out.println("恭喜中了5元！");
} else if (blueHitNumber == 1 && redHitNumber == 3
|| (blueHitNumber == 0 && redHitNumber == 4)) {
System.out.println("恭喜中了10元！");
} else if (blueHitNumber == 1 && redHitNumber == 4
|| (blueHitNumber == 0 && redHitNumber == 5)) {
System.out.println("恭喜中了200元！");
} else if (blueHitNumber == 1 && redHitNumber == 5) {
System.out.println("恭喜中了3000元！");
} else if (blueHitNumber == 0 && redHitNumber == 6) {
System.out.println("恭喜中了500万元！");
} else if (blueHitNumber == 1 && redHitNumber == 6) {
System.out.println("恭喜中了巨奖！");
}
}
main方法中
package test.Demo01;
import java.util.Random;
import java.util.Scanner;
/**
* 需求：双色球系统
*/
public class Test10 {
public static void main(String[] args) {
//1.随机生成一个中奖号码，6个红球号码(1-33，不能重复)，随机一个篮球号码(1-16)
int[] luckNumbers = creatLuckNumber();
printArray(luckNumbers);
//2.调用一个方法，让用户输入7个号码，作为用户选号
int[] userNumbers = userInputNumbers();
printArray(userNumbers);
//3.判断中奖情况
//luckNumber = [12,23,2,15,24,5 9]
//userNumber = [15,13,12,25,24,2 5]
judge(luckNumbers,userNumbers);
}
输出结果：
请你输入第1个红球号码（(1-33),不重复）：
22
请你输入第2个红球号码（(1-33),不重复）：
16
请你输入第3个红球号码（(1-33),不重复）：
24
请你输入第4个红球号码（(1-33),不重复）：
21
请你输入第5个红球号码（(1-33),不重复）：
32
请你输入第6个红球号码（(1-33),不重复）：
27
请输入篮球号码（1-16）：
2
22 16 24 21 32 27 2
官方中奖号码是：
22 16 24 21 32 27 2
你投注号码是：
22 16 24 21 32 27 2
您命中了6个红球
您是否命中了蓝球：是
恭喜中了巨奖！
