Java基础经典案例

案例列表

01减肥计划switch版本

02减肥计划if版本

03逢七跳过

04不死神兔

05百钱白鸡

06数组元素求和

07判断两个数组是否相同

08查找元素在数组中的索引

09数组元素反转

10评委打分

11统计字符串中大小写及数字个数

12求三个整数最大值

13判断数组中是否包含2

14筛选出其中的数字和字母并按照数字在前字母在后的规则排序

15随机生成双色球

16产生随机生成验证码

17.杨辉三角

18程序比较谁的年龄大

19键盘输入3本书按照价格从低到高排序后输出,如果价格相同则按照书名的自然顺序排序

20使用TreeMap集合保存劳模信息,要求以劳模对象为键,家庭住址为值,并按照劳模的年龄从大到小排序后输出

案例实现

01减肥计划switch版本

package com.itheima._01减肥计划switch版本;

import java.util.Scanner;

/**
课前说明:
目标:今天一天都是讲解编程思维相关的题目,有一定的难度。
编程思维:一定是长期的代码训练和书写形成的。
今天的学习目标:理解代码的执行流程和解决思路即可!
所有的问题的解决:写代码、写代码、写代码。

案例需求:
输入星期数,显示今天的减肥活动 周一:跑步 周二:游泳 周三:慢走 周四:动感单车 周五:拳击
周六:爬山 周日:好好吃一顿。

分析步骤:
单值匹配案例,我们直接使用switch。
1、使用扫描器类接收用户输入的星期数。
2、使用switch分支判断用户输入的星期数然后匹配具体分支结果输出即可。
*/
public class ExecDemo {
public static void main(String[] args) {
// 1、使用扫描器类接收用户输入的星期数。
Scanner sc = new Scanner(System.in);
System.out.print(“请您输入星期数:”);
// 在这行代码这里暂停,然后等待用户输入星期后,按了确认键,这里就开始扫描用户输入的星期数交给weekDay
String weekDay = sc.nextLine();

// 2.使用switch分支判断用户输入的星期数然后匹配具体分支结果输出即可。
switch (weekDay) {
case “周一”:
System.out.println(“跑步🏃‍”);
break;
case “周二”:
System.out.println(“游泳🏊‍‍”);
break;
case “周三”:
System.out.println(“慢走‍‍”);
break;
case “周四”:
System.out.println(“动感单车”);
break;
case “周五”:
System.out.println(“拳击”);
break;
case “周六”:
System.out.println(“爬山”);
break;
case “周日”:
System.out.println(“好好吃一顿!”);
break;
default:
System.err.println(“您输入的数据有误!”);
}
}
}

02减肥计划if版本

package com.itheima._02减肥计划if版本;

import java.util.Scanner;

/**
案例需求:
输入星期数,显示今天的减肥活动 周一:跑步 周二:游泳 周三:慢走 周四:动感单车 周五:拳击
周六:爬山 周日:好好吃一顿。

分析步骤:
单值匹配案例,我们也可以使用if。(还是建议用switch更加合适!)
1、使用扫描器类接收用户输入的星期数。
2、使用if分支判断用户输入的星期数然后匹配具体分支结果输出即可。
小结:
单值匹配还是用switch吧。
*/
public class ExecDemo {
public static void main(String[] args) {
// 1、使用扫描器类接收用户输入的星期数。 // ALT +ENTER导入包!
Scanner sc = new Scanner(System.in);
System.out.print(“请您输入星期整数(0-6):”);
// 在这行代码这里暂停,然后等待用户输入星期后,按了确认键,这里就开始扫描用户输入的星期数交给weekDay
// String weekDay = sc.nextLine(); // == 不建议判断字符串的比较!
int weekDay = sc.nextInt(); // ==适合做基本数据类型的比较!

// 2.使用if分支判断用户输入的星期数然后匹配具体分支结果输出即可。
if(weekDay == 0){
System.out.println(“好好吃一顿”);
}else if(weekDay == 1){
System.out.println(“跑步”);
}else if(weekDay == 2){
System.out.println(“游泳”);
}else if(weekDay == 3){
System.out.println(“慢走”);
}else if(weekDay == 4){
System.out.println(“动感单车”);
}else if(weekDay == 5){
System.out.println(“拳击”);
}else if(weekDay == 6){
System.out.println(“爬山”);
}else{
System.err.println(“您的星期数据输入有误!”);
}
}
}

03逢七跳过

package com.itheima._03逢七跳过;

/**
案例需求:
朋友聚会的时候可能会玩一个游戏:逢七过。 规则是:从任意一个数字开始报数,当你要报的数字包
含7或者是7的倍数时都要说:过。 为了帮助大家更好的玩这个游戏,这里我们直接在控制台打印出1-
100之间的满足逢七必过规则的数据。 这样,大家将来在玩游戏的时候,就知道哪些数据要说:过

分析步骤:
分析主干:从1-100中找出包含7以及是7的倍数的那些数据输出!
1、先定义一个循环依次访问到1-100之间的数据。 2 3 4 5 6 …. 99
2、判断当前数据是否包含7或者是否是7的倍数,如果是,输出该数据。
*/
public class ExecDemo {
public static void main(String[] args) {
// 1、先定义一个循环依次访问到1-100之间的数据。 2 3 4 5 6 …. 99
for(int i = 2 ; i <= 99 ; i++) {
// i = 2 3 4 5 6 …. 98 99
// 2.判断当前数据是否包含7或者是否是7的倍数,如果是,输出该数据。 7
// 个位: i % 10
// 十位: i /10
if(i % 10 == 7 || i /10 == 7 || i % 7 == 0 ){
System.out.print(i+” “);
}
}
}
}

04不死神兔

package com.itheima._04不死神兔;

/**
案例需求:
有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,
假如兔子都不死,问第二十个月的兔子对数为多少?

分析步骤:
技巧:归纳推敲、总结规律,写代码实现。
归纳推敲:
月份: 0 1 2 3 4 5 6
对数: 1 1 2 3 5 8 13
总结规律:
从第三个月开始,每个月的对数都是前两个月的对数的和。
写代码实现:
1.定义一个数组存储20个月份的兔子对数。
2.为数组的第一个位置和第二个位置都赋值成1,从数组的第3个位置开始遍历。
3.为每个位置赋值成它的前两个元素的数据的总和: nums[i] = nums[i-1] + nums[i-2]
小结:
归纳推敲:先自己手工算出几个。
总结规律:代码写多了就有了经验
编码实现:
*/
public class ExecDemo {
public static void main(String[] args) {
// 1.定义一个数组存储20个月份每个月的兔子对数
int[] nums = new int[20];
// 2.为数组的第一个位置和第二个位置都赋值成1.
// nums[0] = 1 ;
// nums[1] = 1 ;
nums[0] = nums[1] = 1 ; // 以上简化写法。

// nums = [1 , 1 , ……….]
// 3. 从第三个元素开始为每个位置赋值成它的前两个元素的数据的总和。
for(int i = 2 ; i < nums.length ; i++ ){
// i = 0 1 [2] 3
// 当前元素的元素值赋值成 = 前两个位置的元素和。
nums[i] = nums[i-1] + nums[i-2];
}
// 4.输出第20个月的对数
System.out.println(“第20个月的兔子数据是:”+nums[19]);
// 作业:输出每个月的兔子对数,并按照如上格式输出!
}
}

05百钱白鸡

package com.itheima._05百钱白鸡;

/**
百钱买百:
我国古代数学家张丘建在《算经》一书中提出的数学问题:鸡翁一值钱五,鸡母一值钱三,鸡雏三值钱
一。 百钱买百鸡,问鸡翁、鸡母、鸡雏各几何?

分析步骤:
分析主干: 鸡翁一只5块,鸡母一只3块,三只鸡雏1块,请问100块可以买多少组合,最终的鸡数必须也是100只!
分析步骤:
1.第一步:分析 鸡翁 可以买多少只的范围 : 0<= i <= 20;
2.第二步: 分析 鸡母 可以买多少只的范围 : 0<= j <= 33;
3.第三步:分析 鸡雏 的数量 100 – i – j 。 (总买的鸡数必须刚刚是100。而且要求总金额必须是100元)。
4.第四步:分析 鸡雏必须是3的倍数(每3只3只的买),然后必须三者的总金额刚好是100元的组合才可以输出!
*/
public class ExecDemo {
public static void main(String[] args) {
// a.使用一个循环来选择鸡翁买的只数
for(int i = 0 ; i <= 20 ; i++ ){ // 25 5
// i代表了鸡翁买的只数 0 -20 之间。
// b.使用一个循环选择鸡母的只数
for(int j = 0 ; j <= 33 ; j++ ){
// j 代表了鸡母的只数:0 – 33
// c.得到鸡雏的只数k
int k = 100 – i – j ;
// d.判断三种类型的鸡的总金额是否刚刚好是100元 ,是这种组合的结果就满足了百钱百鸡
// 注意:鸡雏的数量必须刚刚是3的倍数!
if(k % 3 == 0 && i * 5 + j * 3 + k/3 == 100){
System.out.println(“鸡翁:”+i+”,鸡母:”+j +”,鸡雏:”+k);
}
}
}
}
}

06数组元素求和

package com.itheima._06数组元素求和;

/**
案例需求:
有这样的一个数组,元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和, 要求
是:求和的元素个位和十位都不能是7,并且只能是偶数

分析步骤:
0.定义数组。
1.定义变量存储最终求和的结果。
2.遍历数组中的每个元素值。
3.当前元素值必须满足:个位和十位都不能是7,并且只能是偶数 才能够被累加到求和变量中去。
4.循环结束之后输出求和变量即可。
*/

public class ExecDemo {
public static void main(String[] args) {
// 0.定义数组。
int[] arr = {68,27,95,88,171,996,51,210};
// 0 1 2 3 4 5 6
// 1.定义变量存储最终求和的结果。
int sum = 0 ;
// 2.遍历数组中的每个元素值。
for(int i = 0 ; i < arr.length ; i++ ) {
// i = 0 1 2 3 4 5 6 7
// 当前元素值就是:arr[i]
// 3.当前元素值必须满足:个位和十位都不能是7,
// 并且只能是偶数 才能够被累加到求和变量中去。 // 171 /10 = 17 % 10 = 7
if(arr[i] % 10 != 7 && arr[i] / 10 % 10 != 7 && arr[i] % 2==0 ) {
System.out.println(arr[i]);
sum += arr[i]; // 累加满足需要的该值到求和变量sum中去。
}
}
// 4.循环结束之后输出求和变量即可。
System.out.println(“结果是:”+sum);
}
}

07判断两个数组是否相同

package com.itheima._07判断两个数组是否相同;

/**
案例需求:(有点难度)
定义一个方法,用于比较两个数组的内容是否相同和不相同。

int[] arr1 = {10 , 30 , 50 , 70 , 90};
int[] arr2 = {10 , 30 , 50 , 70 , 90};

分析步骤:
a、定义2个数组。
b、定义一个方法封装判断数组内容是否相同的功能,所以这个方法就应该接受2个数组。
这个方法最好给它一个返回值,认为相同返回true, 反之返回false.
b.调用方法传入数组,得到比较结果:false|true。

*/
public class ExecDemo {
public static void main(String[] args) {
// 1.定义2个数组。
int[] arr1 = {10 , 30 , 50 , 70 , 90};
int[] arr2 = {10 , 30 , 50 , 70 , 90};
// 0 1 2 3 4

// 3.传入两个数组到方法中进行比较得到方法的返回值
boolean result = compare(arr1 , arr2);
System.out.println(result);
}

// 2.定义一个方法封装判断数组内容是否相同的功能
public static boolean compare(int[] arr1 , int[] arr2){
// 4.判断2个数组的内容是否相同
// 判断2个数组的长度是否相同,如果长度不相同直接返回false.
if(arr1.length != arr2.length) return false;

// 5.到这儿数组的长度已经是相同的,接下来要判断具体的每个元素值是否也相同!
// 使用一个循环遍历两个数组的元素进行比较
for(int i = 0 ; i < arr1.length ; i++ ) {
// i = 0 1 2 3 4
// 6.判断元素内容是否相同 ,如果发现有一个不同就直接返回false
if(arr1[i] != arr2[i] ) return false;
}

// 7.代码如果执行到这儿了,说明两个数组的每个元素都相同了,直接返回true
return true;
}
}

08查找元素在数组中的索引

package com.itheima._08查找元素在数组中的索引;

import java.util.Scanner;

/**
案例需求:
已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据,查找该数据在数组中的索引。
并在控制台输出找到的索引值。如果没有查找到,则输出-1

分析步骤:
主干:输入一个数据,看它是否在数组中存在,存在返回元素的索引值,不存在返回-1.
1、定义一个数组。
2、接收用户输入一个数据。
3、定义一个方法接收数组和查询的数据,然后在方法中看是否在数组中存在,存在返回元素的索引值,不存在返回-1。
4、调用方法传入数组和数据,得到方法的返回结果。
*/
public class ExecDemo {
public static void main(String[] args) {
// 1、定义一个数组。
int[] arr = {19, 28, 37, 37, 46, 50} ;

// 2、接收用户输入一个数据。
Scanner sc = new Scanner(System.in);
System.out.print(“请输入您要查找的数据:”);
int data = sc.nextInt();

// 4、调用方法传入数组和数据,得到方法的返回结果。
int index = getDataIndex(arr , data);
System.out.println(index);

}

// 3.定义一个方法等着该功能
public static int getDataIndex(int[] arr , int data){
// arr {19, 28, 37, 46, 50}
// i 0 1 2 3 4
// data 37
// 5.判断传入的数组中是否存在该数据,存在返回该数据的索引值,不存在返回-1.
for(int i = 0 ; i < arr.length ; i++ ){
if(arr[i] == data){
return i;
}
}
// 6.如果整个循环遍历完都没有返回索引数据,说明不存在该元素值
return -1;
}
}

09数组元素反转

package com.itheima._09数组元素反转;

/**
案例需求:
已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把该数组中的元素值交换, 交换后的数组 arr = {50,
46, 37, 28, 19}; 并在控制台输出交换后的数组元素

分析步骤:
思路:首尾交换。
1、使用一个循环,定义2个计数器,一个计数器在第一个位置,一个计数器在最后一个位置。
2、控制前面的计算器往前加,后面的计数器往后减。
3、循环条件如何控制,正常交换的条件必须是 : i < j 。(i必须在j的后面才需要交换)
*/
public class ExecDemo {
public static void main(String[] args) {
//int a = 20, b = 10;
// 0.准备数组
int[] arr = {19, 28 , 46, 50};
// i j
// 1、使用一个循环,定义2个计数器,一个计数器在第一个位置,一个计数器在最后一个位置。
// i在数组的第一个索引,j在数组的最后一个索引
for(int i = 0 , j = arr.length – 1 ; i < j ; i++ , j– ){
// 交换 i 和 j位置处的元素。
// 2.定义一个临时变量
int temp = arr[i]; // 19
arr[i] = arr[j];
arr[j] = temp ;
}

// 3.输出数组内容看一下!
for(int i = 0 ; i < arr.length ; i++ ){
System.out.print(arr[i]+” “);
}
}
}

10评委打分

package com.itheima._10评委打分;
import java.util.Random;
/**
案例需求:
在编程竞赛中,有6个评委为参赛的选手打分,分数为0-100的随机整数分。 选手的最后得分为:去掉一个
最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

分析步骤:
1、定义一个数组存储6个评委的分数。
2、随机6个0-100的分数存入到数组中去。
3、输出一下数组中的内容看一下。
4、找出该选手的评分均(去掉最高和最低)。
*/
public class ExecDemo {
public static void main(String[] args) {
// 1、定义一个数组存储6个评委的分数。
int[] scores = new int[6];
// 2.循环6次为当前数组产生随机的6个0-100的分数
Random r = new Random();
for(int i = 0 ; i < scores.length ; i++ ){
// i = 0 1 2 3 4 5
scores[i] = r.nextInt(101); // 0-100 1、把随机数赋值到了数组的当前位置
}
// 3.定义一个方法把数组的内容打印出来看一下!!
printArray(scores);
// 4.计算出该选手的平均分数。
calcAvgScore(scores);
}

public static void calcAvgScore(int[] arr){
// arr [29, 50, 65, 5, 61, 84]
// a、计算出该选手的平均分数。
// b、定义一个变量存储最大值,最小值,总和
int max = arr[0]; // 存储最大值
int min = arr[0]; // 存储最小值
int sum = 0 ; // 求和
// c.遍历数组
for(int i = 0 ; i < arr.length ; i++ ) {
// d.判断最大值
if(arr[i] > max){
max = arr[i];
}

// e.判断最小值
if(arr[i] < min){
min = arr[i];
}

// f.累加求和
sum += arr[i];
}
// g.去掉最高分最低分
int avg = (sum – max – min ) / (arr.length – 2);
System.out.println(“去掉最高分:”+max);
System.out.println(“去掉最低分:”+min);
System.out.println(“去掉最高分最低分后的平均分为:”+avg);
}

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.print(“]”);
System.out.println(); // 换行!
}
}

11统计字符串中大小写及数字个数

1.程序运行后通过键盘录入一个字符串。要求字符串中必须包含:大写字母
2.如果录入的字符串中没有大写字母、要进行给出提示。然后程序可以继续录入字符串
3.如果录入的字符串中有大写字母。那么统计这个字符串中小写字母、大写字母、数字、其他字符出现的个数。程序结束
例如:
请输入一个字符串:
123456abc
您输入的字符串中没有大写字母。请重新输入:
ABC456ghi$%^&D
大写字母有:4个
小写字母有:3个
数字有:3个
其他字符有:4个
代码如下:
package M1;

import java.util.Scanner;

public class M1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println(“请输入一个字符串:”);
String s = sc.next();
int countnum = 0;
int countA = 0;
int counta = 0;
int Qita = 0;
//char[] arr = s.toCharArray();//字符串变成字符数组
StringBuilder sb=new StringBuilder(s);//将键盘录入的值存入sb
for (int i = 0; i < sb.length(); i++) {
char c = sb.charAt(i);//遍历拿到每个字符
if (c >= ‘0’ && c <= ‘9’) {//判断
countnum++;
} else if (c >= ‘a’ && c <= ‘z’) {
counta++;
} else if (c >= ‘A’ && c <= ‘Z’) {
countA++;
} else {
Qita++;
}
}
/*for (int i = 0; i < arr.length; i++) {
if (arr[i] >= ‘0’ && arr[i] <= ‘9’) {
countnum++;
} else if (arr[i] >= ‘a’ && arr[i] <= ‘z’) {
counta++;
} else if (arr[i] >= ‘A’ && arr[i] <= ‘Z’) {
countA++;
} else {
Qita++;
}
}
if (Qita == arr.length) {
System.out.println(“全是字符,重新输入!”);
continue;
}
*/
if (countA==0){//没有大写跳过后续代码,继续循环
System.out.println(“没有大写,请重新输入!”);
continue;
}
System.out.println(“数字” + countnum);
System.out.println(“大写” + countA);
System.out.println(“小写” + counta);
System.out.println(“其他” + Qita);
return;

}

}
}

12求三个整数最大值

package Mn1;

import java.util.Scanner;

public class Mn1 {
public static void main(String[] args) {
// 定义一个方法,该方法用来获取三个整数中的最大值。
// 并在main方法中键盘录入三个整数,然后调用方法,求出录入的三个整数中的最大值。
Scanner sc=new Scanner(System.in);
System.out.println(“请输入第一个整数”);
int num_1=sc.nextInt();
System.out.println(“请输入第二个整数”);
int num_2=sc.nextInt();
System.out.println(“请输入第三个整数”);
int num_3=sc.nextInt();
int[]arr={num_1,num_2,num_3};
int max = Max(arr);
System.out.println(“最大值为:”+max);
}
public static int Max(int[]arr){
int max=arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i]>max){
max=arr[i];
}
}return max;
}
}

13判断数组中是否包含2

package Mn2;

public class Mn2 {
/*定义方法exist,该方法用来判断指定元素在数组中是否存在。
在main方法中定义数组,数组中的元素为{3,5,2,6,1},
调用exist方法,判断该数组中是否包含2,并输出结果。*/
public static void main(String[] args) {
int[] arr = {3, 5, 2, 6, 1};
exist(arr);
}

/*
//方法1
public static void exist(int[] arr) {
int index = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 2) {
index++;
}
}
if (index != -1) {
System.out.println(“包含2”);
} else {
System.out.println(“不包含2”);
}
}

}*/
//方法2:
public static void exist(int[] arr) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 2) {
System.out.println(“包含2”);
return;
}
}
System.out.println(“没有2”);
}
}

 14筛选出其中的数字和字母并按照数字在前字母在后的规则排序

代码如下:

import java.util.Scanner;

public class Moni_3 {
    public static void main(String[] args) {
       /* 遍历下列字符串,筛选出其中的数字和字母并按照数字在前字母在后的规则
        组成一个新的字符串,把组成的新字符串打印在控制台。*/
        Scanner
sc=new Scanner(System.in);
        System.out.println(“请输入:”);
       String s=sc.next();
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c>=’a’&&c<=’z’){
                sb.append(c);
            }
        }
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c<=’9’&&c>=’0′){
                sb.append(c);
            }
        }

        for (int i = 0; i < sb.length(); i++) {
            char c = sb.charAt(i);
            System.out.print(c);
          }

  }

}

15随机生成双色球

需求:

已知双色球由1个蓝色球和6个红色球组成,蓝色球的范围是1–16,红色球的范围是1–33;请使用程序随机生成一组双色球并保存到数组中;然后打印出数组中的这一组数据;

思路:

1:由题目可知需要使用一个长度为7的数组才能保存这一注双色球的数据;并且数据都是需要随机生成的,所以使用数组的动态初始化更合适;

2:蓝色球只有一个,所以可以单独生成并存放到数组的0索引位置;但是需要注意控制随机数的范围;

3:剩下的6个红色球可以使用循环生成并保存到数组中,但是需要注意控制随机数的范围;

4:数组中保存好数据以后,可以对数组遍历,打印数据即可;

代码:

import java.util.Random;
public class ZuoYe1 {
public static void main(String[] args) {
//动态初始化数组
int[] arr = new int[7];
//先生成蓝色球保存到0索引
Random r = new Random();
arr[0] = r.nextInt(16)+1;
//循环生成6个红色球保存到数组的1-6索引位置
for (int i = 1; i <= 6; i++) {
arr[i] = r.nextInt(33)+1;
}
//遍历打印数组中的元素
System.out.print(“本次随机生成的双色球是[第一个是蓝色球,剩余的是红色球]:”);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+” “);
}
}
}

16产生随机生成验证码

package com.heima.meiri.day8;
import java.util.Random;
import java.util.Scanner;
/*
1.str用来存放随机数
2.用一个循环去随机去str字符串里的字符
3.产生随机数位字符串的长度
*/
public class kz2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入要获取几位随机数:”);
int num_1 = sc.nextInt();
String suiji = Suiji(num_1);//传入键盘录入的数字,输入几打印几位数的验证
System.out.println(“随机数为:” + suiji);//打印验证码
}

public static String Suiji(int num) {//定义方法
Random r = new Random();//创建随机数对象
StringBuilder sb = new StringBuilder();//创建sb对象
String s = “abcdefghijklmnpqrstuvwxy0123456789ABCDEFGHIJKLMNPQRSTUVWXYZ”;
将要随机获取的数值存入String变量
for (int i = 1; i < num; i++) {
//num为几就是几位数的验证码
int num_1 = r.nextInt(s.length());
//定义随机数范围位为string s的字符长度
sb.append(s.charAt(num_1));
//因为num1具有随机性,chaAt(索引)为索引位置的字符,将获取到的字符存入sb
}
int i = r.nextInt(num);//定义随机索引
int j = r.nextInt(10);//定义随机数
char f=(char)j;
sb.insert(i, j);//插入0-4随机索引,插入内容为0-9随机数字
return sb.toString();

}
}

 17.杨辉三角

package com.heima.meiri.day6;

public class Yhsj {
public static void main(String[] args) {
Yanghui(5);
}
public static void Yanghui(int a){
int[][]arr=new int[a][a];
for (int i = 0; i < arr.length; i++) {
arr[i][0]=1;
arr[i][i]=1;
if (i>=2){
for (int j = 1; j < i; j++) {
arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
}
}
}
System.out.println(“直角打印;”);
for (int i = 0; i < a; i++) {
for (int j = 0; j <= i; j++) {
System.out.print(arr[i][j]+”\t “);
}
System.out.println();
}
System.out.println(“金字塔打印;”);
for (int i = 0; i < a; i++) {
for (int k=0;k<a-i;k++){
System.out.print(“\t”);
}
for (int j = 0; j <= i; j++) {
System.out.print(arr[i][j]+”\t”+”\t”);
}

System.out.println();
}
System.out.println(“倒金字塔打印;”);
for (int i = a-1; i >= 0; i–) {
for (int k=1;k<a-i;k++){
System.out.print(“\t”);
}
for (int j = 0; j <=i; j++) {
System.out.print(arr[i][j]+”\t”+”\t”);
}
System.out.println();
}
}
}

18程序比较谁的年龄大

请从控制台分别接收两个“生日”,格式为:yyyy年MM月dd日,用程序比较两个生日表示的人的年龄大小关系并打印出结果;

要求:

1:使用Date+SimpleDateFormat完成一遍,

2:再使用LocalDate+DateTimeFormatter完成一遍;

提示:

注意,生日值越小,证明出生的越早,就意味着年龄越大,不要搞反了呦;

package day6.No_3;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.Period;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Scanner;
import java.util.Timer;

/*
键盘录入字符串
使用Date/Loca将字符串转换为毫秒
对比二者毫秒值
*/
public class Demo {
public static void main(String[] args) throws ParseException {

Scanner sc = new Scanner(System.in);
System.out.println(“请输入第一个生日(****年**月**日)”);
String s1 = sc.next();
System.out.println(“请输入第一个生日(****年**月**日)”);
String s2 = sc.next();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(“yyyy年MM月dd日”);
LocalDate localDate = LocalDate.parse(s1, dateTimeFormatter);
LocalDate localDate1 = LocalDate.parse(s2, dateTimeFormatter);
// LocalDate+DateTimeFormatter实现对比
if (localDate.isAfter(localDate1)) {
System.out.println(“第二个大”);
}
if (localDate.isBefore(localDate1)) {
System.out.println(“第一个大”);
}if (localDate.isEqual(localDate1)){
System.out.println(“一样大”);
}

// Date SimpleDateFormat实现对比:

Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyyy年MM月dd日”);
try {
long time1 = simpleDateFormat.parse(s1).getTime();
long time2 = simpleDateFormat.parse(s2).getTime();
if (time1 > time2) {
System.out.println(“第二个大”);
} else if (time1<time2){
System.out.println(“第一个大”);
}else {
System.out.println(“一样大”);
}
} catch (ParseException e) {
e.printStackTrace();
}
}
}

19随机生成8个不重复的10至20之间的随机数并保存Set集合中,然后打印出集合中所有的数据

要求:

使用TreeSet集合实现;

参考代码:

public static void main(String[] args) {
TreeSet<Integer> set = new TreeSet<>();
Random r = new Random();
int count =1;
while (set.size()<8){
int i = r.nextInt(20 – 10 + 1) + 10;
System.out.println(“第”+count++ +”次生成的随机数是:”+i);
set.add(i);
}
System.out.println(“集合中保存的8个不重复的随机数是:”+set);
}

19键盘输入3本书按照价格从低到高排序后输出,如果价格相同则按照书名的自然顺序排序

要求:

1:书以对象形式存在,包含书名和价格(int类型)两个属性;

2:要求即使直接打印书对象的时候,也能看到书的名称和价格,而不是书对象的地址值;

3:分别使用自然排序和比较器排序实现效果;

参考代码:

方式一:

public class Book implements Comparable<Book>{
private String name;
private int price;
@Override
public int compareTo(Book book) {
int i = this.price – book.price;//主要条件
return i==0?this.name.compareTo(book.name):i;//次要条件
}
—–自己补全getter/setter,构造方法,toString方法——
}
测试类的main方法
public static void main(String[] args) {
TreeSet<Book> set = new TreeSet<Book>();
Scanner sc = new Scanner(System.in);
int i=1;
while (true){
System.out.println(“请输入第”+i +”本书的名称:”);
String name = sc.next();
System.out.println(“请输入第”+i +”本书的价格(整数):”);
int price = sc.nextInt();
Book b1 = new Book(name,price);
set.add(b1);
i++;
System.out.println(“添加”+name+” 书已经成功,继续添加请输入1,输入其他数字将结束!”);
int ch = sc.nextInt();
if(ch!=1){
break;
}
}
System.out.println(“您一共添加了:”+set.size()+”本书,分别是:”);
for (Book book : set) {
System.out.println(book);
}
}

方式二:

public class Book{//无需实现接口
private String name;
private int price;
—–自己补全getter/setter,构造方法,toString方法——
}
测试类的main方法
public static void main(String[] args) {
TreeSet<Book> set = new TreeSet<Book>((b1, b2) ->{
int v = b1.getPrice()-b2.getPrice();//主要条件
return v==0?b1.getName().compareTo(b2.getName()):v;//次要条件
} );
Scanner sc = new Scanner(System.in);
int i=1;
while (true){
System.out.println(“请输入第”+i +”本书的名称:”);
String name = sc.next();
System.out.println(“请输入第”+i +”本书的价格(整数):”);
int price = sc.nextInt();
Book b1 = new Book(name,price);
set.add(b1);
i++;
System.out.println(“添加”+name+” 书已经成功,继续添加请输入1,输入其他数字将结束!”);
int ch = sc.nextInt();
if(ch!=1){
break;
}
}
System.out.println(“您一共添加了:”+set.size()+”本书,分别是:”);
for (Book book : set) {
System.out.println(book);
}
}

20请使用TreeMap集合保存劳模信息,要求以劳模对象为键,家庭住址为值,并按照劳模的年龄从大到小排序后输出

信息如下:

18岁的张三,北京

20岁的李四,上海

35岁的王五,天津

21岁的赵六,北京

19岁的田七,上海

要求:

1:劳模类中有姓名和年龄两个属性;

2:添加上述信息后,使用代码删除张三的信息

3:添加上述信息后,使用代码修改李四的家庭住址为郑州

4:使用至少两种方式遍历集合中的信息并输出;

参考代码:

使用迭代器,都能进行修改和删除

修改不会改变值得个数,所以修改可以使用迭代器,也可以直接使用增强for进行修改

@Override
   public int compareTo(Student o) {
       int i = this.age - o.age;
       Collator instance = Collator.getInstance(Locale.CHINESE);//因为值可能为汉字所以使用Collator静态方法,对汉字进行比较方法
       i=i==0?instance.compare(this.name,o.name):i;
       return i;
       //return -i;//因为要从大到小,而默认规则是负数存左边,正数存右边,排序规则根据返回值而定的,所以直接加减负可以直接改变大小原则
  }

 

 class Demo1 {
   public static void main(String[] args) {
       Student s1 = new Student("张三", 23);
       Student s2 = new Student("李四", 24);
       Student s3 = new Student("王五", 25);
       Student s4 = new Student("赵六", 26);
       TreeMap<Student, String> ts = new TreeMap<>();
       ts.put(s1, "北京");
       ts.put(s2, "上海");
       ts.put(s3, "广东");
       ts.put(s4, "深圳");
       Set<Student> keySet = ts.keySet();
//迭代器删除方式,删除key的姓名为李四的键值对
       Iterator<Student> iterator1 = keySet.iterator();
       while (iterator1.hasNext()) {
           Student key = iterator1.next();
           if (key.getName().equals("李四")) {
               iterator1.remove();//此时注意是用的迭代器的删除方法,而不是Map集合的删除方法,使用Map集合删除方法,此处会报错
          }
      }
       //修改方式一:
       //迭代器修改方式,将张三的值修改为郑州
       Iterator<Student> iterator = keySet.iterator();
       while (iterator.hasNext()) {
           Student key = iterator.next();
           if (key.getName().equals("张三")) {
               ts.put(key, "郑州");
               System.out.println("修改成功");
               
          }
      }
       //bug代码:
       /*
       Iterator<Student> iterator = keySet.iterator();
       while (iterator.hasNext()) {
           if (iterator.next().getName().equals("张三")) {
               ts.put(iterator.next(), "郑州");
           }//此逻辑不会编译报错,运行也不报错,但是逻辑不通,,但是会修改到下一个key的值,迭代器的默认指向下一个原理
       }*/
       
        /*
        //修改方式二,增强for修改
        for (Student key : keySet) {
           if (key.getName().equals("张三")){
               ts.put(key,"郑州");
               System.out.println("修改成功");
           }
       }
       */
       System.out.println(ts);
       System.out.println("遍历:");
       for (Student key : keySet) {
           String value = ts.get(key);
           System.out.println(key.getAge() + "岁的" + key.getName() + "," + value);
      }

  }
}