【java】【基础5】使用java基础知识实战案例
目录
案例一：买飞机票
案例二：开发验证码
案例三：评委打分
案例四：数字加密
案例五：数组拷贝
案例六：抢红包
6.1 方案1
6.2 方案2
案例七：找素数
7.1 方法1
7.2 方法2
7.3 方法3
案例八：打印乘法表
案例九：打印三角形
案例十：模拟双色球[拓展案例]
10.1 业务分析、用户投注一组号码
10.2 随机生成一组中奖号码
10.3 判断中奖情况
前言：使用java学习的基础知识，进行案例实战
案例一：买飞机票
package com.runa.define2;
public class MethodDemo9 {
public static void main(String[] args) {
double price = calculate(1000,6,"头等舱");
System.out.println("优惠价格是：" + price);
}
public static double calculate(double price, int month, String type){
// 1 判断当前月份是否淡季还是旺季
if(month >= 5 && month <= 10){
//旺季
//2 判断仓位类型
switch (type){
case "头等舱":
price *= 0.9;
break;
case "经济舱":
price *= 0.85;
break;
}
}else{
//淡季
//2 判断仓位类型
switch (type){
case "头等舱":
price *= 0.7;
break;
case "经济舱":
price *= 0.65;
break;
}
}
return price;
}
}
案例二：开发验证码
package com.runa.define2;
import java.util.Random;
public class MethodDemo10 {
public static void main(String[] args) {
System.out.println("当前生成的验证码为：" + creatCode(4));
}
public static String creatCode(int n){
// 1 定义一个for循环用于控制产生随机字符
Random r = new Random();
// 3 定义一个String类型的变量用于记住产生的每位随机字符
String code = "";
for (int i = 0; i < n; i++) {
// 2 为每个位置生成随机字符,可能是数字、大小写字母
// 思路： 随机一个 0 1 2之间的数字出来，0代表数字，1、2代表大、小写字母
int type = r.nextInt(3); //0 1 2
switch (type){
case 0:
// 随机一个数字字符
code += r.nextInt(10); // 0 - 9 += 这里是连接的作用
break;
case 1:
// 随机一个大写字符 A65 Z 65+25
char ch1 = (char)(r.nextInt(26) + 65);
code += ch1;
break;
case 2:
// 随机一个小写字符 a 97 z 97+25
char ch2 = (char)(r.nextInt(26) + 97);
code += ch2;
break;
}
}
return code;
}
}
案例三：评委打分
package com.runa.define2;
import java.util.Scanner;
public class MethodDemo11 {
public static void main(String[] args) {
System.out.println("当前选手得分是：" + getAveScore(6));
}
public static double getAveScore(int number){
//1 定义一个动态初始化的数组，负责存储后期存储的分数
int[] scores = new int[number];
Scanner sc = new Scanner(System.in);
// 2 遍历数组的每个位置，依次录入评委的分数
for (int i = 0; i < scores.length; i++) {
System.out.println("请您录入第" + (i + 1) + "个评委的分数：");
int sorce = sc.nextInt();
scores[i] = sorce;
}
// 3 从数组当中计算出总分、最高分、最低分
int sum = 0;
int max = scores[0]; //最大值，使用数组的第一个数
int min = scores[0];//最小值，使用数组的第一个数
// 遍历数组找出符合条件数据
for (int i = 0; i < scores.length; i++) {
int score = scores[i];
//求和
sum += scores[i];
// 求最大值
if(scores[i] > max){
max = scores[i];
}
// 求最小值
if(scores[i] < min){
min = scores[i];
}
}
// 4 计算平均分返回
return 1.0 * (sum - max - min)/(number-2);
}
}
案例四：数字加密
package com.runa.define2;
public class MethodDemo12 {
public static void main(String[] args) {
System.out.println("加密后的结果是：" + ercrypt(1983));
}
public static String ercrypt(int number){
// 1 把密码拆分成一个一个的数字，才可以对其进行加密
int[] numbers = split(number);
// 2 遍历这个数组中的每个数字，对其进行加密处理
for (int i = 0; i < numbers.length; i++) {
numbers[i] = (numbers[i] + 5) % 10;
}
// 3 对数组的数字进行反转，把对数组进行反转的操作交给一个独立的方法来完成
reverse(numbers);
// 4 把这些加密的数字拼接起来，作为加密后的结果返回
String data = "";
for (int i = 0; i < numbers.length; i++) {
data += numbers[i];
}
return data;
}
public static void reverse(int[] numbers) {
// 反转数组
for (int i = 0,j = numbers.length - 1; i < j; i++, j--) {
// 把后一位的值交给一个temp存储
int temp = numbers[j];
// 把前一个位置的值给后一位处
numbers[j] = numbers[i];
// 将temp赋值给前一个位置
numbers[i] = temp;
}
}
public static int[] split(int number) {
// number =1983
int[] numbers = new int[4];
numbers[0] = number / 1000;
numbers[1] = (number / 100) % 10;
numbers[2] = (number / 10) % 10;
numbers[3] = number % 10;
return numbers;
}
}
案例五：数组拷贝
package com.runa.define2;
public class MethodDemo13 {
public static void main(String[] args) {
int[] arr = {11, 22, 33};
int[] arr2 = copy(arr);
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("]");
}
public static int[] copy(int[] arr){
// arr = [11, 22, 33]
//1 创建一个长度一样的整型数组
int[] arr2 = new int[arr.length];
// 2 把原数组的元素对应位置赋值给新数组
for (int i = 0; i < arr.length; i++) {
arr2[i] = arr[i];
}
//3 返回新数组
return arr2;
}
}
案例六：抢红包
6.1 方案1
会存在性能问题
package com.runa.define2;
import java.util.Random;
import java.util.Scanner;
public class MethodDemo14 {
public static void main(String[] args) {
int[] arr = {9, 66, 188, 520, 9999};
start(arr);
}
public static void start(int[] moneys){
// moneys = [9, 66, 188, 520, 99999]
// 1 定义一个for循环，控制抽奖5次
Scanner sc = new Scanner(System.in);
Random r = new Random();
for (int i = 1; i <= 5; i++) {
// 2 提示粉丝抽奖
System.out.println("请您输入【任意内容】进行抽奖");
sc.next();//等待用户输入内容，按了回车才能往下走
// 3 为当前的这个分数找一个随机的红包出来
while (true) {
int index = r.nextInt(moneys.length); // 0-4
int money = moneys[index];
// 4 判断这个红包是否不为0
if(money != 0){
System.out.println("恭喜您，您抽中了红包：" + money);
moneys[index] = 0;
break;
}
}
}
System.out.println("活动结束！");
}
}
6.2 方案2
略
案例七：找素数
7.1 方法1
package com.runa.define2;
public class MthodDemo15 {
public static void main(String[] args) {
System.out.println("当前素数的个数是：" + search(101, 200));
}
public static int search(int start, int end){
int count = 0;
//start = 101 end = 200
// 1 定义一个 for循环找到101到200之间的每个数据
for (int i = start; i <= end; i++) {
// 信号位思想
boolean flag = true;//假设的意思:默认认为当中i 记住的数据是素数
// 2 判断当前i 这个数据是否是素数
for (int j = 2; j <= i / 2 ; j++) {
if(i % j == 0){
//i 当前记住的这个数据就不是素数
flag = false;
break;
}
}
// 3 根据判定的结果，决定是否输出i ，是素数才能出展示
if(flag){
System.out.println(i);
count++;
}
}
return count;
}
}
7.2 方法2
使用标签技术
package com.runa.define2;
public class MthodDemo15 {
public static void main(String[] args) {
search(101, 200);
}
public static void search(int start, int end) {
int count = 0;
//start = 101 end = 200
// 1 定义一个 for循环找到101到200之间的每个数据
OUT:
for (int i = start; i <= end; i++) {
// 2 拦截判断该数是否是素数
for (int j = 2; j <= i / 2; j++) {
if (i % j == 0) {
// 这个数不是素数不能打印
continue OUT;// 结束外部循环的当次执行
}
}
count++;
System.out.println(i);
}
System.out.println("个数" + count);
}
}
7.3 方法3
package com.runa.define2;
public class MthodDemo15 {
public static void main(String[] args) {
int count = 0;
for (int i = 101; i <= 200; i++) {
if (check(i)) {
System.out.println(i);
count++;
}
}
System.out.println("素数的总数为：" + count);
}
public static boolean check(int data) {
for (int i = 2; i <= data / 2; i++) {
if (data % i == 0) {
return false;
}
}
return true;
}
}
案例八：打印乘法表
package com.runa.define2;
public class MehodDemo16 {
public static void main(String[] args) {
// 1 定义一个for循环打印多少行
for (int i = 1; i <= 9 ; i++) {
// 2 定义一个内部循环，控制打印多少列
for (int j = 1; j <= i ; j++) {
//
System.out.print(j + "x" + i + "=" + j*i + "\t");
}
System.out.println();//换行
}
}
}
案例九：打印三角形
package com.runa.define2;
public class MethodDemo17 {
public static void main(String[] args) {
// 1 先定义一个循环打印多少行
int n = 5;
for (int i = 1; i <= n; i++) {
//2 控制打印多少空格
for (int j = 1; j <= (n - i); j++) {
System.out.print(" ");
}
// 3 控制打印多少*
for (int j = 1; j <=(2 * i - 1); j++) {
System.out.print(j % 2 == 0 ? " " : "*");
}
// 4 换行
System.out.println("");
}
}
}
案例十：模拟双色球[拓展案例]
10.1 业务分析、用户投注一组号码
package com.runa.define2;
import java.util.Scanner;
public class MethodDemo18 {
public static void main(String[] args) {
int[] userNumbers = userSelectNumbers();
printArray(userNumbers);
}
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("]");
}
// 1 用于让用户投注一组号码（前6个是红球，最后一个是篮球，并返回用户投注号码）
public static int[] userSelectNumbers() {
// 2 创建一个整型数组,用于存储用户投注的7个号码
int[] numbers = new int[7];
Scanner sc = new Scanner(System.in);
//3 遍历前6个位置，存入
for (int i = 0; i < numbers.length - 1; i++) {
//i = 0 1 2 3 4 5
// 4 开始让用户为当前位置投注一个红色号码(1-33)
while (true) {
System.out.println("请您输入第" + (i + 1) + "个红色号码（1-33之间不能重复）：");
int number = sc.nextInt();
// 5 判断用户输入的红球号码是否在1-33之间
if (number < 1 || number > 33) {
System.out.println("对不起！ 您输入的红色球号码不再1-33之间，请重新输入！");
} else {
// 继续判断号码是否重复了
if (exist(numbers, number)) {
// number当前号码重复了
System.out.println("对不起，请选择的号码重复了,请重新输入");
} else {
// number 可以使用
numbers[i] = number;
break;
}
}
}
}
//6 投注最后一个蓝色号码
while (true) {
System.out.println("请您输入最后一个蓝色号码（1-16）：");
int number = sc.nextInt();
// 判断用户输入的红球号码是否在1-16之间
if (number < 1 || number > 16) {
System.out.println("对不起！ 您输入的蓝色球号码不再1-16之间，请重新输入！");
}else {
// 蓝色球合法
numbers[6] =number;
break;
}
}
return numbers;
}
public static boolean exist(int[] numbers, int number) {
// 判断number数字是否在数组numbers中存在
// numbers = [12,25,16,17,19,6]
// number = 14
for (int i = 0; i < numbers.length; i++) {
// 优化，如果数组的元素是0就不找了
if(numbers[i] == 0){
break;
}
// 判断数组元素是否等于输入的number
if(numbers[i] == number){
return true;
}
}
return false;
}
}
10.2 随机生成一组中奖号码
package com.runa.define2;
import java.util.Random;
import java.util.Scanner;
public class MethodDemo18 {
public static void main(String[] args) {
int[] userNumbers = userSelectNumbers();
printArray(userNumbers);
int[] luckNumbers = createLuckNumbers();
printArray(luckNumbers);
}
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("]");
}
// 1 用于让用户投注一组号码（前6个是红球，最后一个是篮球，并返回用户投注号码）
public static int[] userSelectNumbers() {
// 2 创建一个整型数组,用于存储用户投注的7个号码
int[] numbers = new int[7];
Scanner sc = new Scanner(System.in);
//3 遍历前6个位置，存入
for (int i = 0; i < numbers.length - 1; i++) {
//i = 0 1 2 3 4 5
// 4 开始让用户为当前位置投注一个红色号码(1-33)
while (true) {
System.out.println("请您输入第" + (i + 1) + "个红色号码（1-33之间不能重复）：");
int number = sc.nextInt();
// 5 判断用户输入的红球号码是否在1-33之间
if (number < 1 || number > 33) {
System.out.println("对不起！ 您输入的红色球号码不再1-33之间，请重新输入！");
} else {
// 继续判断号码是否重复了
if (exist(numbers, number)) {
// number当前号码重复了
System.out.println("对不起，请选择的号码重复了,请重新输入");
} else {
// number 可以使用
numbers[i] = number;
break;
}
}
}
}
//6 投注最后一个蓝色号码
while (true) {
System.out.println("请您输入最后一个蓝色号码（1-16）：");
int number = sc.nextInt();
// 判断用户输入的红球号码是否在1-16之间
if (number < 1 || number > 16) {
System.out.println("对不起！ 您输入的蓝色球号码不再1-16之间，请重新输入！");
}else {
// 蓝色球合法
numbers[6] =number;
break;
}
}
return numbers;
}
public static boolean exist(int[] numbers, int number) {
// 判断number数字是否在数组numbers中存在
// numbers = [12,25,16,17,19,6]
// number = 14
for (int i = 0; i < numbers.length; i++) {
// 优化，如果数组的元素是0就不找了
if(numbers[i] == 0){
break;
}
// 判断数组元素是否等于输入的number
if(numbers[i] == number){
return true;
}
}
return false;
}
// 系统随机一组中奖号码（前6个是红球，最后一个是篮球，并返回这组中奖号码）
public static int[] createLuckNumbers(){
// 1 创建一个整型数组,用于存储用户投注的7个号码
int[] numbers = new int[7];
Random r = new Random();
//2 遍历前6个位置，依次从（1-33之间）随机一个红球号码存入（不重复）
for (int i = 0; i < numbers.length - 1; i++) {
//i = 0 1 2 3 4 5
// 3 开始让用户为当前位置投注一个红色号码(1-33)
while (true) {
int number = r.nextInt(33) + 1;
//4 判断number是否重复,这样是不重复才进去
if(!exist(numbers,number)){
// number 正常可以使用
numbers[i] = number;
break;
}
}
}
// 5 录入一个人蓝球号码 1-16
numbers[6] = r.nextInt(16) +1;
return numbers;
}
}
10.3 判断中奖情况
package com.runa.define2;
import java.util.Random;
import java.util.Scanner;
public class MethodDemo18 {
public static void main(String[] args) {
int[] userNumbers = userSelectNumbers();
System.out.println("您投注的号码：");
printArray(userNumbers);
int[] luckNumbers = createLuckNumbers();
System.out.println("中奖号码：");
printArray(luckNumbers);
judge(userNumbers,luckNumbers);
}
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("]");
}
// 1 用于让用户投注一组号码（前6个是红球，最后一个是篮球，并返回用户投注号码）
public static int[] userSelectNumbers() {
// 2 创建一个整型数组,用于存储用户投注的7个号码
int[] numbers = new int[7];
Scanner sc = new Scanner(System.in);
//3 遍历前6个位置，存入
for (int i = 0; i < numbers.length - 1; i++) {
//i = 0 1 2 3 4 5
// 4 开始让用户为当前位置投注一个红色号码(1-33)
while (true) {
System.out.println("请您输入第" + (i + 1) + "个红色号码（1-33之间不能重复）：");
int number = sc.nextInt();
// 5 判断用户输入的红球号码是否在1-33之间
if (number < 1 || number > 33) {
System.out.println("对不起！ 您输入的红色球号码不再1-33之间，请重新输入！");
} else {
// 继续判断号码是否重复了
if (exist(numbers, number)) {
// number当前号码重复了
System.out.println("对不起，请选择的号码重复了,请重新输入");
} else {
// number 可以使用
numbers[i] = number;
break;
}
}
}
}
//6 投注最后一个蓝色号码
while (true) {
System.out.println("请您输入最后一个蓝色号码（1-16）：");
int number = sc.nextInt();
// 判断用户输入的红球号码是否在1-16之间
if (number < 1 || number > 16) {
System.out.println("对不起！ 您输入的蓝色球号码不再1-16之间，请重新输入！");
}else {
// 蓝色球合法
numbers[6] =number;
break;
}
}
return numbers;
}
public static boolean exist(int[] numbers, int number) {
// 判断number数字是否在数组numbers中存在
// numbers = [12,25,16,17,19,6]
// number = 14
for (int i = 0; i < numbers.length; i++) {
// 优化，如果数组的元素是0就不找了
if(numbers[i] == 0){
break;
}
// 判断数组元素是否等于输入的number
if(numbers[i] == number){
return true;
}
}
return false;
}
// 系统随机一组中奖号码（前6个是红球，最后一个是篮球，并返回这组中奖号码）
public static int[] createLuckNumbers(){
// 1 创建一个整型数组,用于存储用户投注的7个号码
int[] numbers = new int[7];
Random r = new Random();
//2 遍历前6个位置，依次从（1-33之间）随机一个红球号码存入（不重复）
for (int i = 0; i < numbers.length - 1; i++) {
//i = 0 1 2 3 4 5
// 3 开始让用户为当前位置投注一个红色号码(1-33)
while (true) {
int number = r.nextInt(33) + 1;
//4 判断number是否重复,这样是不重复才进去
if(!exist(numbers,number)){
// number 正常可以使用
numbers[i] = number;
break;
}
}
}
// 5 录入一个人蓝球号码 1-16
numbers[6] = r.nextInt(16) +1;
return numbers;
}
// 传入两组号码，判断是否中奖，并输出
public static void judge(int[] userNumbers, int[] luckNumbers){
//userNumbers = [2,3,12,23,25,33,8]
//luckNumbers= [12,13,22,23,25,33,8]
// 1 分别定义两个遍历用于记住红球命中几个，蓝球命中几个
int redCount = 0;
int blueCount = 0;
// 2 先判断红球命中数量，遍历用户投注号码的前6个红球
for (int i = 0; i < userNumbers.length - 1; i++) {
// userNumbers[i]
//开始遍历中奖号码的前6红球号码，看用户当前选择的号码是否命中
for (int j = 0; j < luckNumbers.length - 1; j++) {
if(userNumbers[i] == luckNumbers[j]){
redCount++;
break;
}
}
}
// 3 判断蓝球是否命中了
blueCount = userNumbers[6] == luckNumbers[6] ? 1 : 0;
System.out.println("您命中的红球数量是：" + redCount);
System.out.println("您命中的蓝球数量是：" + blueCount);
// 4 判断中奖详情，并输出结果
if(redCount == 6 && blueCount ==1){
System.out.println("恭喜你，中奖1000万，可以开始享受人生了~~~");
}else if(redCount == 6 && blueCount ==0){
System.out.println("恭喜你，中奖500万，可以稍微享受人生了~~~");
}else if(redCount == 5 && blueCount ==1){
System.out.println("恭喜你，中奖3000元，可以出去吃小龙虾了~~~");
}else if(redCount == 5 && blueCount ==0){
System.out.println("恭喜你，中奖200元~~");
}else if(redCount == 4 && blueCount ==0 || redCount == 3 && blueCount ==1){
System.out.println("恭喜你，中奖10元~");
}else if(redCount < 3 && blueCount ==1){
System.out.println("恭喜你，中奖5元~");
}else{
System.out.println("感谢您对福利事业做贡献~~~");
}
}
}