案例列表
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);
}
}
}