1、定义一个方法,该方法能够找出两个小数中的较小值并返回。
public class Demo1 {
public static void main(String[] args) {
System.out.println(getMinNumber(1.1, 2.1));
System.out.println(getMinNumber(2.1, 1.1));
}
//参数列表 double a,double b
//返回值类型 double
public static double getMinNumber(double a, double b) {
//找出两个小数中的较小值并返回
//表达式 ? 正确值 : 错误值
return a < b ? a : b;
}
}
2、定义一个方法判断整数数组中某一个数是否存在,并将结果返回
public class Demo2 {
public static void main(String[] args) {
System.out.println(isExists(new int[]{2, 4, 6, 8, 0}, 3));//false
System.out.println(isExists(new int[]{2, 4, 6, 8, 0}, 4));//true
}
//参数列表: int[] arr, int num [1 2 3 4 5] 3
//返回值类型: boolean
public static boolean isExists(int[] arr, int num) {
//1. 数组遍历
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
//数在数组中的
return true;
}
}
//当for循环结束了, 还没有返回true 数不在数组中的
return false;
}
}
3、定义一个方法统计指定范围(例如100~200)之间能被3整除的数,并将数放入一个数组中返回
public class Demo3 {
public static void main(String[] args) {
int[] array = getArray(100, 200);
System.out.println(array);//[I@776ec8df
System.out.println(Arrays.toString(array));//[102,105.....198]
}
//参数int min,int max
//返回int[]
public static int[] getArray(int min, int max) {
//1. 遍历一遍,找出所有满足条件的数的个数
//1-1 声明计数器
int count = 0;
//1-2 使用for遍历数组
for (int i = min; i <= max; i++) {
//判断i是否可以整除3
if (i % 3 == 0) {
count++;
}
}
//2. 准备数组
int[] arr = new int[count];
//3. 将满足条件的数据放入数组
//3-1 再来声明一个递增计数器,表示数组中正在填充数据的索引
int index = 0;
for (int i = min; i <= max; i++) {
//判断i是否可以整除3
if (i % 3 == 0) {
arr[index++] = i;
}
}
//4. 返回
return arr;
}
}
4、定义一个方法,接收一个整型数组,判定数组中的元素是否是升序排列,并将结果返回
public class Demo4 {
public static void main(String[] args) {
System.out.println(isAsc(new int[]{1, 3, 5, 7, 9}));
System.out.println(isAsc(new int[]{1, 5, 3, 7, 9}));
}
//以后一旦使用到了索引+1 千万注意索引越界
//参数 int[] arr
//返回值 boolean
public static boolean isAsc(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
if (arr[i] >= arr[i + 1]) {
return false;//一旦发现有一个前面元素大于后面的元素, 此时数组就已经判断为非升序
}
}
//当上面的循环执行完毕,依旧没有返回false; 代表数组中的每个元素都满足后边大于前边
return true;
}
}
5、设计一个方法,可以接收1个整数n(比如4)来代表行数,然后使用方法打印出下面的图形状
打印效果如下:
@
@@
@@@
@@@@
public class Demo5 {
public static void main(String[] args) {
print(4);
}
//参数 int num
//返回值 void
public static void print(int num) {
//外层for控制行
for (int i = 1; i <= num; i++) {
//内存for控制列
for (int j = 0; j < i; j++) {
System.out.print("@");
}
//换行
System.out.println();
}
}
}
6、数字是有绝对值的,非负数的绝对值是它本身,负数的绝对值是它本身取反。
请定义一个方法,方法能够得到小数类型数字的绝对值并返回。请定义方法并测试。
public class Demo6 {
public static void main(String[] args) {
System.out.println(getAbs(1.1));
System.out.println(getAbs(-1.1));
}
//参数 double num
//返回值 double
public static double getAbs(double num) {
if (num >= 0) {
//>=0 非负数
return num;
} else {
//<0 负数
return num * -1;
}
}
}
7、定义一个方法,接收两个整数作为数值范围,然后在控制台打印出范围内之间的满足逢七必过
的数
逢七必过规则(数字包含7或者是7的倍数)
public class Demo7 {
public static void main(String[] args) {
print(10, 20);
}
//参数 int min,int max
//返回 void
public static void print(int min, int max) {
//判断, 如果不是两位整数,直接返回
if ((min < 10 || min > 99) || (max < 10 || max > 99)) {
return;//结束
}
//根据min--max做一个循环,找到里面所有的数
for (int i = min; i <= max; i++) {
//i: 一个范围内的数
//求i的个位和十位
int ge = i % 10;
int shi = i / 10 % 10;
if (ge == 7 || shi == 7 || i % 7 == 0) {
continue;//跳过本次 继续下次
}
System.out.println(i);
}
}
}
8、定义一个方法,接收一个小数数组(小数点后只有1位),然后找出数组中准整数
有几个返回
准整数指的是小数点之后全是0的小数
public class Demo8 {
public static void main(String[] args) {
System.out.println(count(new double[]{1.1, 1.2, 1.0, 2.0, 3.1}));
}
//[1.1, 1.2, 1.0, 2.0, 3.1]
//参数 double[] arr
//返回值 int
public static int count(double[] arr){
//1. 定义一个计数器
int count = 0;
//2. 循环遍历数组
for (int i = 0; i < arr.length; i++) {
if (((int)(arr[i] * 10)) % 10 == 0) {
count++;
}
}
return count;
}
}
9、请定义一个方法,对正数的小数进行四舍五入的操作(不考虑负数情况)。
四舍五入之后的结果是一个int整数类型并返回。
提示:四舍五入的操作关键是十分位(小数第一位),如何获取十分位?
public class Demo9 {
public static void main(String[] args) {
System.out.println(getNum(10.51));//11
System.out.println(getNum(10.21));//10
}
//参数列表 double num
//返回值 int
public static int getNum(double num) {
//1. 获取每个小数的十分位(小数 * 10 取各位数)
int shifenwei = ((int) (num * 10)) % 10;
//2. 根据十分位的值,确定返回值
if (shifenwei >= 5) {
return (int)num + 1;
} else {
return (int)num;
}
}
}
10、现有一个整数数组,数组中的每个元素都是[0-9]之间的数字,从数组的最大索引位置开始到最小索引位置,依次表示整数的个位、十位、百位。。。依次类推。请编写程序计算,这个数组所表示的整数值。例如:
数组:{2, 1, 3, 5, 4}
表示的整数为:21354 // 注:是整数类型的两万一千三百五十四,不是字符串拼起来的。
public class Demo10 {
public static void main(String[] args) {
System.out.println(getNum(new int[]{2, 1, 3, 5, 4}));
System.out.println(getNum(new int[]{8, 2, 1, 3, 5, 4}));
System.out.println(getNum(new int[]{1, 3, 5, 4}));
}
//参数 int[] arr
//返回值 int
public static int getNum(int[] arr) {
//{2, 1, 3, 5, 4}---->21354
// 2 * 10 * 10 * 10 * 10 4
// 1 * 10 * 10 * 10 3
// 3 * 10 * 10 2
// 5 * 10 1
// 4
//变量 累加
int sum = 0;
//i 0 1 2 3
for (int i = 0; i < arr.length; i++) {
//arr[i] * 10 * 10
sum += mul(arr[i], arr.length - 1 - i);
}
return sum;
}
//求num*n次10的结果
public static int mul(int num, int times) {
for (int i = 0; i < times; i++) {
num = num * 10;
}
return num;
}
}
11、定义一个数组其中包含多个数字。用自己的方式最终实现,奇数放在数组的左边,偶数放在数组的右边。(可以创建其他数组,不必须在原数组中改变)
public class Demo11 {
public static void main(String[] args) {
int[] newArr = getArr(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
System.out.println(Arrays.toString(newArr));
}
//参数 int[] arr
//返回 int[]
public static int[] getArr(int[] arr) {
//1. 创建一个新数组(类型和长度)
int[] newArr = new int[arr.length];
//2.定义两个指针,分别指向新数组的首尾位置
// int left = 0;
// int right = arr.length - 1;
int left = 0, right = arr.length - 1;
//3. 遍历原有数组, 分析每个元素是奇数还是偶数
for (int i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 0) {
//偶数
newArr[right] = arr[i];
right--;//指针向左移动
} else {
//奇数
newArr[left] = arr[i];
left++;//指针向右移动
}
}
//4. 将新数组返回
return newArr;
}
}
12、已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据,查找该数据在数组中第一次出现的索引。
并在控制台输出找到的索引值。如果没有查找到,则输出-1
public class Demo12 {
public static void main(String[] args) {
findIndex();
}
//参数列表
//返回值void
public static void findIndex(){
//0. 创建键盘对象
Scanner scanner = new Scanner(System.in);
//1. 定义数组
int[] arr = {19, 28, 37, 19, 50};
//2. 键盘录入一个数据
System.out.println("请输入要查找的元素");
int target = scanner.nextInt();//19
//3. 遍历数组,获取每个元素,跟目标元素进行比对,
for (int i = 0; i < arr.length; i++) {
if (arr[i] == target) {
//如果比对中了, 直接输出当前元素的索引值;
System.out.println(i);
return;
//break: 结束循环 跳出循环,但是依旧会执行循环后面的代码
//return: 结束程序
}
}
//当for循环走完之后,依旧没有找到,此时输出-1
System.out.println(-1);
}
}
13、能够合理的设计方法参数和返回值, 并调用方法
需求描述:模拟一个简单的考试管理系统, 已知成绩为 10, 20, 30, 40, 50, 60, 70, 80
实现提示:
/*
System.out.println("--------------------------");
System.out.println("欢迎来到黑马考试管理系统");
System.out.println("1. 查看成绩");
System.out.println("2. 查看最高分");
System.out.println("3. 查看最低分");
System.out.println("4. 查看平均分");
System.out.println("5. 查看不及格人数");
System.out.println("6. 退出");
System.out.println("--------------------------");
*/
public class Demo13 {
public static void main(String[] args) {
scoreSystem();
}
//参数 无
//返回值 void
public static void scoreSystem() {
//0. 定义键盘对象
Scanner scanner = new Scanner(System.in);
//1. 定义数组
int[] scores = new int[]{10, 20, 30, 40, 50, 60, 70, 80};
//死循环
outer:
while (true) {
//2. 输出菜单提示
System.out.println("--------------------------");
System.out.println("欢迎来到黑马考试管理系统");
System.out.println("1. 查看成绩");
System.out.println("2. 查看最高分");
System.out.println("3. 查看最低分");
System.out.println("4. 查看平均分");
System.out.println("5. 查看不及格人数");
System.out.println("6. 退出");
System.out.println("--------------------------");
//3. 从键盘输入想要做的事情
int flag = scanner.nextInt();
//4. 使用switch判断要执行的分支
switch (flag) {
case 1:
//查看成绩
System.out.println(Arrays.toString(scores));
break;
case 2:
//查看最高分
int max = getMaxScore(scores);
System.out.println("最高分为:" + max);
break;
case 3:
//查看最低分
int min = getMinScore(scores);
System.out.println("最低分为:" + min);
break;
case 4:
//查看平均分
double avg = getAvgScore(scores);
System.out.println("平均分为:" + avg);
break;
case 5:
//查看不及格人数
int count = getCount(scores);
System.out.println("不及格人数为:" + count);
break;
case 6:
//退出
break outer;
default:
System.out.println("您输入有误");
}
}
}
//查看不及格人数
public static int getCount(int[] scores) {
int count = 0;
for (int i = 0; i < scores.length; i++) {
if (scores[i] < 60) {
count++;
}
}
return count;
}
//查看平均分
public static double getAvgScore(int[] scores) {
//总分
int sum = 0;
for (int i = 0; i < scores.length; i++) {
sum += scores[i];
}
return sum * 1.0 / scores.length;
}
//查看最低分
public static int getMinScore(int[] scores) {
int min = scores[0];
for (int i = 0; i < scores.length; i++) {
if (min > scores[i]) {
min = scores[i];
}
}
return min;
}
//获取最高分
public static int getMaxScore(int[] scores) {
int max = scores[0];
for (int i = 0; i < scores.length; i++) {
if (max < scores[i]) {
max = scores[i];
}
}
return max;
}
}