Java基础-day06

Debug操作和前5天总结

一、 Debug界面常用按钮详解

二、 总结习题

习题一 if语句实现减肥计划

public class LoseWeight_If {

	/*
		使用if语句实现减肥计划
	 */
	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		System.out.println("请输入星期数：");
		int week = sc.nextInt();

		if (week < 1 || week > 7) {
			System.out.println("输入有误");
		} else if (week == 1) {
			System.out.println("跑步");
		}else if (week == 2) {
			System.out.println("游泳");
		}else if (week == 3) {
			System.out.println("慢走");
		}else if (week == 4) {
			System.out.println("单车");
		}else if (week == 5) {
			System.out.println("拳击");
		}else if (week == 6) {
			System.out.println("爬山");
		}else{
			System.out.println("好好吃一顿");
		}
	}
}

习题二 switch语句实现减肥计划

public class LoseWeight_If {

	/*
		使用if语句实现减肥计划
	 */
	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		System.out.println("请输入星期数：");
		int week = sc.nextInt();

		if (week < 1 || week > 7) {
			System.out.println("输入有误");
		} else if (week == 1) {
			System.out.println("跑步");
		}else if (week == 2) {
			System.out.println("游泳");
		}else if (week == 3) {
			System.out.println("慢走");
		}else if (week == 4) {
			System.out.println("单车");
		}else if (week == 5) {
			System.out.println("拳击");
		}else if (week == 6) {
			System.out.println("爬山");
		}else{
			System.out.println("好好吃一顿");
		}
	}
}

习题三 斐波那契数列问题

public class RabbitDemo {

	/*
		斐波那契数列问题
			斐波那契数列前n项：1,1,2,3,5,8...（从第3项起后一个数等于前两数之和）
	 */

	public static void main(String[] args) {

	//	System.out.println(fibonacci(20));

		int sum = 0;
		for (int i = 1; i <= 20; i++) {
			sum += fibonacci(i);
		}
		System.out.println("第二十天的兔子总对数为：" + sum + " 对");
	}


	private static int fibonacci(int n) {	//递归调用方法求斐波那契数列第n项
		if (n == 1 || n == 2) {
			return 1;
		} else {
			return fibonacci(n - 1) + fibonacci(n - 2);
		}
	}
}

习题四 百钱百鸡问题

public class ChickenDemo {

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

		思路：
			1.第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为x = 0; 判断条件是x <= 20;
			2.第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为y = 0; 判断条件为y <= 33;
			3.这个时候用于表示鸡雏的变量 z = 100 - x - y;
			4.判断表达式 z % 3 == 0 和表达式 5 * x + 3 * y + z / 3 == 100是否同时成立，若成立则输出对应的x, y, z 的值，
			  就是对应的鸡翁，鸡母和鸡雏的值

	 */
	public static void main(String[] args) {

		chickenJudge();
	}

	private static void chickenJudge() {
		//1.第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为x = 0; 判断条件是x <= 20;
		for (int x = 0; x <= 20; x++) {
			//2.第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为y = 0; 判断条件为y <= 33;
			for (int y = 0; y <= 33; y++) {
				//3.这个时候用于表示鸡雏的变量 z = 100 - x - y;
				int z = 100 - x - y;
				//判断表达式 z % 3 == 0 和表达式 5 * x + 3 * y + z / 3 == 100是否同时成立
				if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
					System.out.println(x + ", " + y + ", " + z);
				}
			}

		}
	}
}

习题五 判断两数组内容是否相同

public class ArrayContentCompare {

	/*
		判断两个数组中的内容是否相同
	 */
	public static void main(String[] args) {

		int[] arr1 = {11, 22, 33, 44, 55, 66};
		int[] arr2 = {11, 22, 33, 44, 55, 66};

		System.out.println(contentCompare(arr1, arr2));

	}

	//返回值类型为boolean，两个参数为int[] arr1,int[] arr2
	private static boolean contentCompare(int[] arr1, int[] arr2) {

		//判断两个数组的长度是否相同，若不同则直接返回false
		if (arr1.length != arr2.length) {
			return false;
		}

		//逐个判断数组中的每一个元素是否相同，但凡有一个不同则返回false
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
			/*
			如果在if后方加上else语句会导致遇到第一个相同的元素的时候返回true，
			 方法直接中断。
			 */
		}

		//若以上两个条件都不满足，则返回true
		return true;
	}
}

习题六 判断两个数组内容是否相同（进阶）

public class PrimerArrayCompare {

	/*
		判断两个数组中的内容是否一致。
			对一致的定义：只需要内容全部相同，不需要元素顺序相同。
		思路：
			1. 判断两个数组长度是否相同，若长度不同直接返回false；
			2. 遍历第一个数组，求出每个元素在第一个数组中的个数，同时遍历第二个数组，
			判断相同元素在第二个数组中的个数。
			3. 判断相同元素在各自数组中的个数是否相同，如果不同返回false
			4. 如果以上条件都不满足，返回true
	 */
	public static void main(String[] args) {

		int[] arr1 = {11, 22, 11, 33, 22, 44, 55, 66};
		int[] arr2 = {11, 11, 22, 55, 22, 44, 33, 66};

		System.out.println(arr1);
		System.out.println(arr2);
		System.out.println(arrayCompare(arr1, arr2));

	}

	private static boolean arrayCompare(int[] arr1, int[] arr2) {

		//判断两个数组长度是否相同，若长度不同直接返回false；
		if (arr1.length != arr2.length) {
			return false;
		}
				/*
					遍历第一个数组，求出每个元素在第一个数组中的个数，同时遍历第二个数组，
					判断相同元素在第二个数组中的个数。
				*/

		for (int e : arr1) {    //遍历数组1, 因为两个数组等长，也相当于遍历数组2

			int count_1 = 0;
			int count_2 = 0;

			for (int j = 0; j < arr1.length; j++) {        //分别遍历两个数组
				if (e == arr1[j]) {
					count_1++;        //求出元素e在数组1中的数量
				}
				if (e == arr2[j]) {        //求出元素e在数组2中的数量
					count_2++;
				}

			}

			//判断元素e在各自数组中的个数是否相同，如果不同返回false
			if (count_1 != count_2) {
				return false;
			}
		}

		//如果以上条件都不满足，返回true
		return true;
	}
}

习题七 1~100逢七过

public class PassSeven {

	//逢7过
	public static void main(String[] args) {

		int count = 0;
		for (int i = 1; i <= 100; i++) {
			count++;
			if (count % 5 == 0) {	// 每五个换一行
				System.out.println(i);
			} else {
				if ((i % 7 == 0) || (i % 10 == 7) || (i / 10 == 7)) {
					System.out.print("pass ");
					continue;
				}
				System.out.print(i + "  ");
			}

		}
	}

}

习题八 查找数组中某元素的索引值

public class ArrayQuery {

	/*
		需求：
			已知一个数组，从键盘键入一个数，在该数组中查询该数的索引值，
			并在控制台输出其索引值。
	 */
	public static void main(String[] args) {

		int[] arr = {11,22,33,44,55,66};
		int e;
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你想要查找的元素：");
		e = sc.nextInt();

		if (query(arr, e) != -1) {	//若返回值不为-1代表数组中有该元素
			System.out.println("你要查找的元素索引是：" + query(arr,e));
		} else {	//若返回值是-1代表数组中没有该元素
			System.out.println("你查找的元素没有包含在该数组内");
		}


	}

	//返回值类型为int, 两个参数类型为int[] arr, int e
	private static int query(int[] arr, int e) {

		for (int i = 0; i < arr.length; i++) {	//遍历数组，若元素e存在于数组中，返回其索引值
			if (arr[i] == e) {
				return i;
			}
		}
		return -1;	//返回-1代表数组中没有该元素
	}
}

习题九 按特定条件对数组内容求和

public class ArraySum {

	/*
		数组内容求和, 要求被求和的元素个位和十位都不能是7, 并且为偶数
	 */
	public static void main(String[] args) {

		int[] arr = new int[5];
		autoInitArray(arr);
		System.out.println("数组中的元素有：");
		printArray(arr);
		System.out.println("-----------");
		System.out.println("数组元素之和为：");
		System.out.println(arraySum(arr));


	}

	//返回值类型为void, 参数类型为int[] arr
	private static void autoInitArray(int[] arr) {    //自动初始化数组

		Random rd = new Random();
		for (int i = 0; i < arr.length; i++) {
			arr[i] = rd.nextInt(100) + 1;
		}
	}
	//返回值类型为void, 参数类型为int[] arr
	private static void printArray(int[] arr) {    //格式化输出数组内容

		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				System.out.print(arr[i]);
			} else {
				System.out.print(arr[i] + ", ");
			}
		}
		System.out.println("]");
	}

	//返回值类型为int,参数类型为int[] arr
	private static int arraySum(int[] arr) {

		int sum = 0;
		for (int i : arr) {        //数组求和

			//若该元素个位和十位都没有7，且为偶数，累加
			//如果元素为偶数，其个位注定不能是7, 因此可以省略判断条件 i % 10 != 7
			if ((i / 10 != 7) && (i % 2 == 0)) {
				sum += i;
			}
		}

		return sum;
	}

}

习题十 反转数组中的内容

public class ArrayReverse {

	//数组内容反转
	public static void main(String[] args) {

		int[] arr = {11, 22, 33, 44, 55, 66,77};

		System.out.println("反转前的数组为：");
		printArray(arr);
		System.out.println("------------------");
		System.out.println("反转后的数组为：");
		printArray(reverseArray(arr));
	}

	private static int[] reverseArray(int[] arr) {

		int temp;

	/*
		int mid = arr.length / 2;
		int head = 0;
		int tail = arr.length - 1;

		//方法一：以数组索引中值为界，前后对称位置元素互换
		for (int i = 0; i <= mid; i++) {

			temp = arr[head];
			arr[head] = arr[tail];
			arr[tail] = temp;
			head++;
			tail--;
		}
		*/

		//方法二：设置首尾索引，当首索引小于尾索引时，交换对称位置上的元素，当首尾索引相等或首索引大于尾索引时，
		// 说明已达到或越过索引中值，可以结束交换
		for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
			temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;
		}
		return arr;
	}

	private static void printArray(int[] arr) {

		for (int i : arr) {
			System.out.print(i + "\t");
		}
		System.out.println();
	}
}

习题十一 根据评委打分求选手平均分的案例

public class Judgement {

	/*
		需求：
			在编程比赛中，选手的得分为6名评委所打分数（0~100）去掉最高分和
			最低分之后的4个得分求平均数（忽略小数）。
	 */
	public static void main(String[] args) {

		int[] arr = new int[6];
		autoInitArray(arr);
	//	manuallyInitArray(arr);
		System.out.println("6评委打分为：");
		printArray(arr);
		System.out.println("----------------");
		System.out.println("最高分为：" + getMax(arr));
		System.out.println("最低分为：" + getMin(arr));
		System.out.println("平均分为：" + getAvg(arr));
	}

	//返回值类型为void, 参数类型为int[] arr
	private static void autoInitArray(int[] arr) {    //自动初始化数组

		Random rd = new Random();
		for (int i = 0; i < arr.length; i++) {
			arr[i] = rd.nextInt(100) + 1;
		}
	}

/*
	//返回值类型为void, 参数类型为int[] arr
	private static void manuallyInitArray(int[] arr) {    //手动初始化数组

		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < arr.length; i++) {
			System.out.printf("请输入第%d位评委的打分：\n", (i + 1));
			arr[i] = sc.nextInt();
		}
	}
	*/

	//返回值类型为int, 参数类型为int[] arr
	private static int getMax(int[] arr) {    //获取数组中的最大值

		int max = arr[0];
		for (int i = 1; i < arr.length; i++) {
			max = Math.max(max, arr[i]);
		}
		return max;
	}

	//返回值类型为int, 参数类型为int[] arr
	private static int getMin(int[] arr) {    //获取数组中的最小值

		int min = arr[0];
		for (int i = 1; i < arr.length; i++) {
			min = Math.min(min, arr[i]);
		}
		return min;
	}

	//返回值类型为int, 参数类型为int[] arr
	private static int getAvg(int[] arr) {

		int sum = 0;
		for (int i : arr) {		//数组求和
			sum += i;
		}

		//返回除去最高分和最低分之后的平均分
		return (sum - getMax(arr) - getMin(arr)) / (arr.length - 2);
	}

	//返回值类型为void, 参数类型为int[] arr
	private static void printArray(int[] arr) {    //格式化输出数组内容

		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				System.out.print(arr[i]);
			} else {
				System.out.print(arr[i] + ", ");
			}
		}
		System.out.println("]");
	}

}

arr
private static int getAvg(int[] arr) {

	int sum = 0;
	for (int i : arr) {		//数组求和
		sum += i;
	}

	//返回除去最高分和最低分之后的平均分
	return (sum - getMax(arr) - getMin(arr)) / (arr.length - 2);
}

//返回值类型为void, 参数类型为int[] arr
private static void printArray(int[] arr) {    //格式化输出数组内容

	System.out.print("[");
	for (int i = 0; i < arr.length; i++) {
		if (i == arr.length - 1) {
			System.out.print(arr[i]);
		} else {
			System.out.print(arr[i] + ", ");
		}
	}
	System.out.println("]");
}

}