>[danger] ##### 飞机票买票
1. 机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折
2. 将计算票价部分进行了方法抽取
~~~
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
/*
* 机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
* 按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。
*/
Scanner sc = new Scanner(System.in);
// 输入票价
System.out.print("请输入票价");
double ticket = sc.nextDouble();
// 输入购买月份
System.out.print("请输入月份");
int month = sc.nextInt();
// 输入购买 仓位 1头等 2经济
System.out.print("请输入仓位 1头等 2经济");
int seat = sc.nextInt();
// 判读月份
if (month >= 5 && month <= 10) {
ticket = getTicket(ticket, seat, 0.9, 0.85);
// if (seat == 1) {
// ticket *= 0.9;
// } else if (seat == 2) {
// ticket *= 0.85;
// } else {
// System.out.print("没有这个舱位");
// }
} else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
ticket = getTicket(ticket, seat, 0.7, 0.65);
// if (seat == 1) {
// ticket *= 0.7;
// } else if (seat == 2) {
// ticket *= 0.65;
// } else {
// System.out.print("没有这个舱位");
// }
} else {
System.out.print("输入月份不存在");
}
System.out.println(ticket);
}
// 将计算票价部分抽取方法
public static double getTicket(double ticket, int seat, double v1, double v2) {
if (seat == 1) {
ticket *= v1;
} else if (seat == 2) {
ticket *= v2;
} else {
System.out.print("没有这个舱位");
}
return ticket;
}
}
~~~
>[danger] ##### 计算质数
1. 判断 101 ~ 200 之间有多少个素数，并打印所有素数
~~~
public class Test {
public static void main(String[] args) {
// 质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。定义 质数又称素数
// 判断 101 ~ 200 之间有多少个素数，并打印所有素数
int count = 0;
for (int i = 101; i <= 200; i++) {
boolean flag = true;
for (int j = 2; j < i; j++) {
if (i % j == 0) {
flag = false;
break;
}
}
if (flag) {
count++;
}
}
System.out.println("一共有" + count + "个质数");
}
}
~~~
>[danger] ##### 随机验证码
1. 定义方法实现随机产生一个5位的验证码，前四位是大写字母或者小写字母，最后一位是数字
~~~
import java.util.Random;
public class Test {
public static void main(String[] args) {
/*
* 需求：
* 定义方法实现随机产生一个5位的验证码
* 验证码格式：
* 长度为5
* 前四位是大写字母或者小写字母
* 最后一位是数字
*/
// 定义一个保存大小写字母的数组
char[] chs = new char[52];
// 利用ascii 码一次将 字母存在字符串
for (int i = 0; i < chs.length; i++) {
// 将数字转换为char 类型
if (i < 26) {
chs[i] = (char) (65 + i);
} else {
chs[i] = (char) (97 + i - 26);
}
}
// 定义一个字符串类型的变量，用来记录最终的结果
String result = "";
// 从数组中随机取出
Random r = new Random();
for (int i = 0; i < 4; i++) {
int randomIndex = r.nextInt(chs.length);
// 利用随机索引，获取对应的元素
// System.out.println(chs[randomIndex]);
result = result + chs[randomIndex];
}
// 3.随机抽取一个数字0~9
int number = r.nextInt(10);
// 生成最终的结果
result = result + number;
// 打印最终结果
System.out.println(result);
}
}
~~~
>[danger] ##### 评委打分
1. 在唱歌比赛中，有6名评委给选手打分，分数范围是\[0 - 100\]之间的整数。选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。
~~~
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
int[] sources = getSources(4);
int max = getMaxSource(sources);
int min = getMinSource(sources);
int sumSource = sum(sources);
double avg = (sumSource - max - min) / (sources.length - 2);
System.out.print(avg);
}
// 分数录入
public static int[] getSources(int s) {
Scanner sc = new Scanner(System.in);
int[] sources = new int[4];
for (int i = 0; i < s;) {
System.out.print(i + 1 + "号评委打分");
int source = sc.nextInt();
if (source <= 100) {
sources[i] = source;
i++;
} else {
System.out.println("成绩超出了范围,继续录入，当前的i为：" + i + 1);
}
}
return sources;
}
// 数组求和
public static int sum(int[] sources) {
int sumSource = 0;
for (int i = 0; i < sources.length; i++) {
sumSource += sources[i];
}
return sumSource;
}
// 获取数组中的最小值
public static int getMinSource(int[] sources) {
int min = sources[0];
for (int i = 1; i < sources.length; i++) {
if (min > sources[i]) {
min = sources[i];
}
}
return min;
}
// 获取数组中的最大值
public static int getMaxSource(int[] sources) {
int max = sources[0];
for (int i = 1; i < sources.length; i++) {
if (max < sources[i]) {
max = sources[i];
}
}
return max;
}
}
~~~
>[danger] ##### 转换加密
~~~
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
/*
* 某系统的数字密码（大于0）。比如1983，采用加密方式进行传输，
* 规则如下：
* 每位数加上5
* 再对10求余，
* 最后将所有数字反转，
* 得到一串新数。
*/
int[] arr = { 1, 9, 8, 3 };
// 每一位加五然后对10求余
for (int i = 0; i < arr.length; i++) {
int temp = arr[i];
temp += 5;
temp %= 10;
arr[i] = temp;
}
// 将数组前后交换定义两个指针
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
System.out.print(Arrays.toString(arr)); // 8346
}
}
~~~
>[danger] ##### 将加密密码反向推到
~~~
package com.itheima.test;
public class Test8 {
public static void main(String[] args) {
/*
* 某系统的数字密码（大于0）。比如1983，采用加密方式进行传输，
* 规则如下：
* 每位数加上5
* 再对10求余，
* 最后将所有数字反转，
* 得到一串新数。
* 按照以上规则进行解密：
* 比如1983加密之后变成8346，解密之后变成1983
*/
// 1.定义数组记录解密之后的结果
int[] arr = { 8, 3, 4, 6 };
// 2.反转
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 3.由于加密是通过对10取余的方式进行获取的
// 所以在解密的时候就需要判断因为出现数字都是在0-9之间
// 加5后范围是 5 -14 直接，相对 14为例 如果加密后是4 则原本为14
// 0~4之间+10 5~9数字不变
for (int i = 0; i < arr.length; i++) {
if (arr[i] >= 0 && arr[i] <= 4) {
arr[i] = arr[i] + 10;
}
}
// 4.每一位减5
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] - 5;
}
// 5.获取数组里面的每一位数字拼接成最终的结果
int number = 0;
for (int i = 0; i < arr.length; i++) {
number = number * 10 + arr[i];
}
System.out.println(number);
}
}
~~~
>[danger] ##### 将数字每一位存在数组
1. 给定一个数字 1234 变成数组形式`[1,2,3,4]`
~~~
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int num = 1234;
// 临时保存
int temp = num;
// 计算出当前数字位数
int count = 0;
while (num != 0) {
num /= 10;
count++;
}
int[] nums = new int[count];
int index = nums.length - 1;
while (temp != 0) {
int ge = temp % 10;
temp /= 10;
nums[index--] = ge;
}
// 验证结果 1 2 3 4
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + " ");
}
}
}
~~~
>[danger] ##### 打乱数组位置
* 方式一
~~~
import java.util.Random;
public class Test9 {
public static void main(String[] args) {
/* 需求：
一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。
请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
打印效果如下：（随机顺序，不一定是下面的顺序）
888元的奖金被抽出
588元的奖金被抽出
10000元的奖金被抽出
1000元的奖金被抽出
2元的奖金被抽出
*/
//分析：
//1.定义数组表示奖池
int[] arr = {2, 588, 888, 1000, 10000};
//2.定义新数组用于存储抽奖的结果
int[] newArr = new int[arr.length];
//3.抽奖
Random r = new Random();
//因为有5个奖项，所以这里要循环5次
for (int i = 0; i < 5; ) {
//获取随机索引
int randomIndex = r.nextInt(arr.length);
//获取奖项
int prize = arr[randomIndex];
//判断当前的奖项是否存在，如果存在则重新抽取，如果不存在，就表示是有效奖项
boolean flag = contains(newArr, prize);
if(!flag){
//把当前抽取到的奖项添加到newArr当中
newArr[i] = prize;
//添加完毕之后，移动索引
i++;
}
}
//4.遍历newArr
for (int i = 0; i < newArr.length; i++) {
System.out.println(newArr[i]);
}
}
//判断prize在数组当中是否存在
//存在：true
//不存在：false
public static boolean contains(int[] arr,int prize){
for (int i = 0; i < arr.length; i++) {
if(arr[i] == prize){
return true;
}
}
return false;
}
}
~~~
* 方式二
~~~
import java.util.Random;
public class Test10 {
public static void main(String[] args) {
/* 需求：
一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。
请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
打印效果如下：（随机顺序，不一定是下面的顺序）
888元的奖金被抽出
588元的奖金被抽出
10000元的奖金被抽出
1000元的奖金被抽出
2元的奖金被抽出
*/
//1.把奖池里面的所有奖项打乱顺序
int[] arr = {2, 588, 888, 1000, 10000};
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
//获取随机索引
int randomIndex = r.nextInt(arr.length);
//拿着i跟随机索引randomIndex上的值进行交换
int temp = arr[i];
arr[i] = arr[randomIndex];
arr[randomIndex] = temp;
}
//2.遍历奖池,从0索引开始获取每一个奖项
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
~~~
>[danger] ##### 双色球随机数
~~~
import java.util.Random;
import java.util.Scanner;
public class Test11 {
public static void main(String[] args) {
//1.生成中奖号码
int[] arr = createNumber(); // 123456 7
System.out.println("=======================");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println("=======================");
//2.用户输入彩票号码（红球 + 蓝球）//654321
int[] userInputArr = userInputNumber();
//3.判断用户的中奖情况
//红球 蓝球
int redCount = 0;
int blueCount = 0;
//判断红球
for (int i = 0; i < userInputArr.length - 1; i++) {
int redNumber = userInputArr[i];
for (int j = 0; j < arr.length - 1; j++) {
if(redNumber == arr[j]){
redCount++;
//如果找到了，那么后面的数字就没有必要继续比较了
//跳出内循环，继续判断下一个红球号码是否中奖
break;
}
}
}
//判断蓝球
int blueNumber = userInputArr[userInputArr.length-1];
if(blueNumber == arr[arr.length - 1]){
blueCount++;
}
//根据红球的个数以及蓝球的个数来判断中奖情况
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) || (redCount == 4 && blueCount == 1)){
System.out.println("恭喜你，中奖200");
}else if((redCount == 4 && blueCount == 0) || (redCount == 3 && blueCount == 1)){
System.out.println("恭喜你，中奖10");
}else if((redCount == 2 && blueCount == 1) || (redCount == 1 && blueCount == 1)|| (redCount == 0 && blueCount == 1)){
System.out.println("恭喜你，中奖5");
}else{
System.out.println("谢谢参与，谢谢惠顾");
}
}
public static int[] userInputNumber() {
//1.创建数组用于添加用户购买的彩票号码
//6个红球 1个蓝球 数组长度：7
int[] arr = new int[7];
//2.利用键盘录入让用输入
Scanner sc = new Scanner(System.in);
//让用户输入红球号码
for (int i = 0; i < 6; ) {
System.out.println("请输入第" + (i + 1) + "个红球号码");
int redNumber = sc.nextInt();
//redNumber 在1~33 唯一不重复
if (redNumber >= 1 && redNumber <= 33) {
boolean flag = contains(arr, redNumber);
if (!flag) {
//不存在
//有效的，可以添加到数组当中
arr[i] = redNumber;
i++;
} else {
//存在
System.out.println("当前红球号码已经存在，请重新输入");
}
} else {
System.out.println("当前红球号码超出范围");
}
}
//让用户输入篮球号码
System.out.println("请输入篮球号码");
//1~16
while (true) {
int blueNumber = sc.nextInt();
if (blueNumber >= 1 && blueNumber <= 16) {
arr[arr.length - 1] = blueNumber;
break;
} else {
System.out.println("当前篮球号码超出范围");
}
}
return arr;
}
public static int[] createNumber() {
//1.创建数组用于添加中奖号码
//6个红球 1个蓝球 数组长度：7
int[] arr = new int[7];
//2.随机生成号码并添加到数组当中
//红球：不能重复的 1 2 3 4 5 6
//蓝球：可以跟红球号码重复 5
//生成红球号码并添加到数组当中
Random r = new Random();
for (int i = 0; i < 6; ) {
//获取红球号码
int redNumber = r.nextInt(33) + 1;
boolean flag = contains(arr, redNumber);
if (!flag) {
//把红球号码添加到数组当中
arr[i] = redNumber;
i++;
}
}
//生成蓝球号码并添加到数组当中
int blueNumber = r.nextInt(16) + 1;
arr[arr.length - 1] = blueNumber;
return arr;
}
//用于判断数组在数组中是否存在
public static boolean contains(int[] arr, int number) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == number) {
return true;
}
}
return false;
}
}
~~~
- windows -- 环境变量
- Vscode -- 编写java
- 初始java
- java -- 关键字
- 编写第一个java程序
- java -- 注释
- 计算机存储 -- 进制
- java -- 类型
- java -- 变量
- 数字类型
- 布尔类型
- 字符类型
- 类型转换
- 双等比较是什么
- java -- 运算符
- 算数运算符
- 字符串拼接
- 关系/比较运算符
- 自增减运算符
- 逻辑运算符
- 三目运算
- 赋值运算符
- 移位运算符
- 位运算符
- 运算符优先级
- java -- 流程控制语句
- if /else if /if -- 判断
- switch case分支结构
- for -- 循环
- 用双重for循环
- while -- 循环
- do while -- 循环
- 案例练习
- java -- 数组
- 数组的存储
- 数组的增删改查
- 数组的特点
- 数组案例
- 二维数组
- 数组的工具方法
- java -- 方法
- java -- 方法的重载
- java -- 方法的调用流程
- java -- 类方法传参注意事项
- java -- 方法练习案例
- 对比 return break continue
- for each循环
- java -- 基础练习
- java -- 面向对象
- java -- 创建类和对象
- java -- 访问控制符
- java -- 类成员方法
- java -- 构造方法
- java -- this
- java -- 封装
- java -- 对象内存图
- java -- 创建对象案例
- java -- static
- java -- 继承
- super -- 关键字
- java -- 构造块和静态代码块
- java -- 重写
- java -- final
- java -- 多态
- java -- 抽象类
- java -- 接口
- 引用类型数据转换
- 综合案例
- java -- 内部类
- java -- 回调模式
- java -- 枚举类型
- java -- switch 使用枚举
- java -- 枚举方法使用
- java -- 枚举类实现接口
- java -- javaBean
- java -- package 包
- java -- import
- java -- 递归练习
- java -- 设计模式
- 单例模式
- java -- 注解
- java -- 元注解
- Java -- 核心类库
- java -- 处理字符串
- Java -- String
- String -- 常用方法
- String -- 正则
- Java -- StringBuilder 和 StringBuffer
- 知识点
- Java -- StringJoiner 字符串拼接
- 练习题
- 字符串的总结
- Java -- 包装类
- Integer
- Double
- Boolean
- Character
- java -- 集合类
- java -- util.Collection
- Iterator接口
- java -- util.List
- java -- ArrayList
- java -- util.Queue
- java -- util.Set
- java -- util.Map
- java -- util.Collections
- Java -- Math
- Java -- java.lang
- Java -- Object
- Java -- 获取当前时间戳
- Java -- 异常
- Java -- java.util
- java -- Date
- java -- Calender
- Java -- java.text
- Java -- SimpleDateFormat
- Java -- java.time
- Java -- java.io
- java -- io.File
- java -- 泛型
- IDEA -- 用法