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);
}
}
}
Java基础经典案例的更多相关文章
- 【视频+图文】Java基础经典练习题（一）输出2-100之间的素数，及素数个数
目录 第一题:判断2-100之间有多少个素数,并输出所有素数. 1.视频讲解: 2.思路分析: 代码讲解:以i=4为例 4.为大家准备了彩蛋: 能解决题目的代码并不是一次就可以写好的 我们需要根据我们 ...
- Java多线程经典案例分享
汇总 案例一 案例二 案例三 案例四 案例五 案例六 案例七 案例一 实现一个容器,提供两个方法,add(),count() 写两个线程,线程1添加10个元素到容器中,线程2实现监控元素的个数,当个数 ...
- JAVA基础经典面试
[前言] 整理好久,这篇总结写的超级好,很全面.要全部背下来,至于框架应用那块,一定要有针对的,多写项目,照着慕课的对应项目. 链接:http://www.importnew.com/22083.ht ...
- java基础 -- 经典排序
---- 冒泡排序 方法: 1.每次比较相邻的两个数 2. 小的交换在前面 3.每轮结束后最大的数交换到最后 代码实现: /* * 冒泡排序 * */ public class SortNum { ...
- 汇总java生态圈常用技术框架、开源中间件，系统架构及经典案例等
转自:http://www.51testing.com/html/83/n-3718883.html 有人认为编程是一门技术活,要有一定的天赋,非天资聪慧者不能及也.非也,这是近几年,对于技术这碗饭有 ...
- 经典的Java基础面试题集锦
经典的Java基础面试题集锦,欢迎收藏和分享. 问题:如果main方法被声明为private会怎样? 答案:能正常编译,但运行的时候会提示”main方法不是public的”. 问题:Java里的传引用 ...
- Java基础知识总结（超级经典）
Java基础知识总结(超级经典) 写代码: 1,明确需求.我要做什么? 2,分析思路.我要怎么做?1,2,3. 3,确定步骤.每一个思路部分用到哪些语句,方法,和对象. 4,代码实现.用具体的java ...
- 毕向东—Java基础知识总结（超级经典）
Java基础知识总结(超级经典) 写代码: 1,明确需求.我要做什么? 2,分析思路.我要怎么做?1,2,3. 3,确定步骤.每一个思路部分用到哪些语句,方法,和对象. 4,代码实现.用具体的java ...
- Java基础-处理json字符串解析案例
Java基础-处理json字符串解析案例 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 作为一名开发人员,想必大家或多或少都有接触到XML文件,XML全称为“extensible ...
随机推荐
- Python匹配对象的groups、groupdict和group之间的关系
匹配对象的groups()方法返回一个包含所有参与匹配的子组(不含组0)的匹配到的搜索文本子串的元组,groupdict返回一个包含所有匹配到的命名组的组名为键值和命名组匹配到的搜索文本子串为值作为元 ...
- 第14.12节 Python中使用BeautifulSoup解析http报文：使用select方法快速定位内容
一. 引言 在<第14.10节 Python中使用BeautifulSoup解析http报文:html标签相关属性的访问>和<第14.11节 Python中使用BeautifulSo ...
- PyQt学习随笔：Model和View之间的数据互动过程
在<PyQt学习随笔:Qt中tem Views(Model-Based)和Item Widgets(Item-Based)控件的用途和关系>中介绍了,Model用于存储数据,View用于展 ...
- AtCoder Regular Contest 107(VP)
Contest Link Official Editorial 比赛体验良好,网站全程没有挂.题面简洁好评,题目质量好评.对于我这个蒟蒻来说非常合适的一套题目. A. Simple Math Prob ...
- 把java编译成exe和安装包
由于某些项目甲方迟迟不结算尾款,这就很烦,只能想一些办法 我们知道java,python之类的代码是没有隐私可言的,那么怎么办,总要发给甲方验收,这就要做一些操作来确保自己的利益. 通过在源代码里加上 ...
- 部署在GitHub的个人博客如何绑定个人域名
前提是已经搭建好了自己的个人博客 如果想要搭建自己的个人博客可以来我的个人博客学习呀 地址 购买域名 首先想要绑定域名,总归需要去购买一个属于自己的域名吧,我是在腾讯云上面购买的域名(不是广告) 在腾 ...
- Linux安装Mysql8.0.20并配置主从复制（一主一从，双主双从）
1. 主从复制解释 将主数据库的增删改查等操作记录到二进制日志文件中,从库接收主库日志文件,根据最后一次更新的起始位置,同步复制到从数据库中,使得主从数据库保持一致. 2. 主从复制的作用 高可用 ...
- GET和POST的区别与联系
每日知识-GET和POST HTTP:超文本传输协议 组成部分:请求行,请求头部,一个空行,请求数据 GET和POST GET:get就是获取的意思,默认的HTTP请求方式,把参数通过 key/val ...
- [日常摸鱼]Luogu2878 [USACO07JAN]Protecting the Flowers
直接贴题面x 有$n$头奶牛跑到FJ的花园里去吃花儿了,它们分别在距离牛圈$T$分钟处吃花儿,每分钟会吃掉$D$朵卡哇伊的花儿,FJ现在要将它们给弄回牛圈,但是他每次只能弄一头回去,来回用时总共为$2 ...
- Git - 简单的使用与Github
Github: Following the instructions to create repo. Git on Linux(centos): download the latest GIT and ...