数组练习

求最小值
需求:获取指定数组中偶数元素值的最小值1.定义一个int数组arr
2.键盘录入5个整数，存入数组arr 中，并且录入之前提示输入的是第几个数字
3.获取指定数组arr 中偶数元素值的最小值，并在控制台打印

/*
		 *  求最小值
		 *      本题使用的技术点
		 *    1.数组、数据类型
		 *    2.输入指令、输出指令、循环结构
		 *    3.变量、选择结构、循环结构、输出指令
		 * */
		
		// 1.定义一个int数组arr
		int[] arr = new int[5];
		
		// 2.键盘录入5个整数 存入数组arr中，并录入之前提示输入的是第几个数字
		Scanner input = new Scanner(System.in);
		for (int i = 0; i < arr.length; i++) {
			System.out.printf("第%d个数字是：", i+1);
			arr[i] = input.nextInt();
		}
		// 3.获取数组arr中偶数的最小值
		// 假定一个最小值 注意： 最小值和最大值都应该从比较的范围中选择
		int min = -1;
		int count = 0;
		for (int i = 0; i < arr.length; i++) {
			// 给最小值赋值第一个偶数
			if (count == 0 && arr[i] % 2 == 0) {
				min = arr[i];
				count++;
				continue;
			}
			// 比较最小值
			if (arr[i] % 2 == 0 && arr[i] < min) {
				min = arr[i];
			}
		}
		if (min == -1) {
			System.out.println("该数组中没有偶数！");
		} else {
			System.out.println("该数组偶数的最小值为：" + min);
		}
	}

求差值
需求1:获取到数组中最大值和最小值的差值
1.获取键盘录入的5个整数，并存放在int 数组arr中，输入前提示输入的是第几个值。
2.分别获取数组中最大值和最小值，并计算差值。3.输出差值。

	/*本道题所有的技术点
		 *  1.变量、数据类型、循环结构、数组、输出指令、输入指令
		 *  2.变量、 运算符、选择结构、循环结构
		 *  3.输出指令
		 * 
		 * */
		// 1:获取到数组中最大值和最小值的差值
		Scanner input = new Scanner(System.in);
		
		int[] arr = new int[5];
		for (int i = 0 ; i < arr.length; i++) {
			System.out.printf("第%d个数字是：", i+ 1);
			arr[i] = input.nextInt();
		}
		// 2分别获取数组中最大值和最小值，并计算差值。
		int max = arr[0];
		int min = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
			if (arr[i] < min) {
				min = arr[i];
			}
		}
		// 3.输出差值。
		System.out.println("最大值为：" + max);
		System.out.println("最小值为：" + min);
		System.out.println("最大值和最小值的差值为：" + (max-min));
	}

需求2:获取数组元素的偶数和与奇数和之差
1.获取键盘录入的5个整数，并存放在int数组arr中，输入前提示输入的是第几个值;
2.分别获取数组中元素的偶数和与奇数和;3.输出偶数和与奇数和的差值

/* 本道题所有的技术点
		 *  1.变量、数据类型、循环结构、数组、输出指令、输入指令
		 *  2.变量、选择结构、循环结构
		 *  3.输出指令
		 * 
		 * */
		// 1获取键盘录入的5个整数，并存放在int数组arr中输入前提示输入的是第几个值:
		int[] arr = new int[5];
		Scanner input = new Scanner(System.in);
		for (int i = 0; i < arr.length; i++) {
			System.out.printf("第%d个数字是：", i+1);
			arr[i] = input.nextInt();
		}
		// 2.分别获取数组中元素的偶数和与奇数和;
		int even = 0;
		int odd = 0;
		for (int num : arr) {
			if (num % 2 == 0) {
				even += num;
			} else {
				odd += num;
			}
		}
		// 3输出偶数和与奇数和的差值
		if (even > odd) {
			System.out.println("偶数和与奇数和的差值为：" + (even - odd));
		} else {
			System.out.println("偶数和与奇数和的差值为：" + (odd - even));
		}
	}

个数统计
需求1:获取指定数组中元素值为偶数的元素个数1.定义一个整数数组arr
2.获取5个0~50之间(包含0和50)的随机数，并存入arr
3.获取指定数组arr中元素值为偶数的元素个数，并打印

/* 本道题所有的技术点
		 *  1.数据类型、数组
		 *  2.变量、循环结构、随机数
		 *  3.输出指令、选择结构、循环结构
		 * 
		 *	 需求1:获取指定数组中元素值为偶数的元素个数
		 *	1定义一个整数数组arr
		 *	2获取5个0~50之间(包含0和50)的随机数，并存入arr
		 *	3获取指定数组arr中元素值为偶数的元素个数，并打印
		 * */
		// 1定义一个整数数组arr
		int[] arr = new int[5];
		
		// 2获取5个0~50之间(包含0和50)的随机数，并存入arr
		for (int i = 0; i < arr.length; i++) {
			// 生成的随机数范围：[0,51]
			arr[i] = (int) (Math.random() * 51);
			System.out.println(arr[i]);
		}
		
		// 3获取指定数组arr中元素值为偶数的元素个数，并打印
		int count = 0;
		for (int num : arr) {
			if (num % 2 == 0) {
				count ++;
			}
		}
		System.out.println("数组中元素值为偶数的元素个数为：" + count);
	}

需求2:获取指定数组中大于指定整数的元素个数1.获取键盘录入的5个整数，并存放在int 数组arr中，输入前提示输入的是第几个值
2.键盘录入一个需要进行比较的整数num3.计算数组arr 中比整数num大的元素个数查询下标

	/*本道题所有的技术点
		 *  1.、数据类型、循环结构、数组、输入指令
		 *  2.变量、 输入指令 、输出指令
		 *  3.循环结构、选择结构
		 *  4.输出指令
		 *  
		 *      需求2:获取指定数组中大于指定整数的元素个数
		 *	1获取键盘录入的5个整数，并存放在int数组arr中输入前提示输入的是第几个值
		 *	2键盘录入一个需要进行比较的整数num
	 	 *	3计算数组arr中比整数num大的元素个数
		 * */
		// 1获取键盘录入的5个整数，并存放在int数组arr中输入前提示输入的是第几个值
		Scanner input = new Scanner(System.in);
		int[] arr = new int[5];
		for (int i = 0; i < arr.length; i++) {
			System.out.printf("第%d个数字是：", i + 1);
			arr[i] = input.nextInt();
		}
		// 	2键盘录入一个需要进行比较的整数num
		System.out.println("需要比较的数：");
		int num = input.nextInt();
		
		// 3计算数组arr中比整数num大的元素个数
		int count = 0;
		for (int val : arr) {
			if (val > num) {
				count++;
			}
		}
		System.out.println("数组中比整数【" + num + "】大的元素个数为：" + count);
	}

需求:查询指定元素值在指定数组中的下标值
1.创建int 数组arr, arr包含11,32，55, 47，55,79，23
2.输入任意一个整数num
3.遍历数组，如果指定数组arr中不存在指定整数
num，那么输出-1，指定数组arr中存在多个相同的指定整数num，那么输出num值对应的最大下标标值(最后的num对应的下标)

	/*本道题所有的技术点
		 *  1.、数据类型、数组、
		 *  2.变量、 输入指令 、输出指令
		 *  3.循环结构、选择结构
		 *  4.输出指令
		 *  
		   *      需求:查询指定元素值在指定数组中的下标值
		 *	1创建int数组arr,arr包含1132，55,47，5579，23
		 *	2输入任意一个整数num
		 *	3遍历数组，如果指定数组arr中不存在指定整数 num，那么输出-1，指定数组arr中存在多个相同的指定整数num，
		 *	那么输出num值对应的最大下标标值(最后的num对应的下标)
		 * */
	
		// 1创建int数组arr,arr包含1132，55,47，5579，23
		int[] arr = {11, 32, 55, 47, 55, 79, 23};	
		
		// 	2输入任意一个整数num
		Scanner input = new Scanner(System.in);
		System.out.println("请输入任意一个整数：");
		int num = input.nextInt();
		
		// 3.差值num在arr中的下标位置
		// 定义变量储存下标位置
		int index = -1;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == num) {
				index = i;
				break;
			}
		}
		System.out.printf("%d在数字中的下标值为：%d\n", num, index);
	}

替换值
需求:用指定整数替换指定数组中的元素值
1.创建int 数组arr，数组内包含0-9之间的10个整数2.获取键盘录入的一个整数num，如果num为偶数，则用num替换指定数组arr 中的所有偶数下标的元素值
如果num为奇数，则用num替换指定数组arr 中所有的奇数下标的元素值
3.输出替换值之后的数组arr

	/* 本道题所有的技术点
		 *  1.数组
		 *  2.变量、 输入指令 、输出指令
		 *  3.循环结构、选择结构
		 *  4.输出指令、循环结构
		 *  
		  *  需求:用指定整数替换指定数组中的元素值
		 *	1创建int数组arr数组内包含0-9之间的10个整数
		 *	2获取键盘录入的一个整数num，如果num为偶
		 *	数，则用num替换指定数组arr中的所有偶数下标的元素值
		 *	如果num为奇数，则用num替换指定数组arr中所有的奇数下标的元素值
		 *	3输出替换值之后的数组arr
		 */
		// 1.创建int数组arr
		int[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
		// 2.键盘录入一个整数num
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个整数：");
		int num = input.nextInt();
		
		// 3.判断是奇数还是偶数，然后进行替换
		for (int i = 0; i < arr.length; i++) {
			if (num % 2 == 0 && i % 2 == 0) {
				arr[i] = num;
			} else if (num % 2 != 0 && i % 2 != 0) {
				arr[i] = num;
			}
		}
		/*if (num % 2 == 0) {
			// 替换偶数下标元素
			for (int i = 0; i < arr.length; i++) {
				if (i % 2 == 0) {
					arr[i] = num;
				}
			}
		} else {
			// 替换奇数下标元素
			for (int i = 0; i < arr.length; i++) {
				if (i % 2 != 0) {
					arr[i] = num;
				}
			}
		}*/
		// 4.输出数组
		for (int val : arr) {
			System.out.print(val + "  ");
		}
	}

去除值
需求:去除数组中所有的数值01.定义一个数组oldArr，元素为1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5
2.去除所有为0的元素值,并存入到一个新的数组newArr，效果为1,3,4,5,6,6,5,4,7,6,7,5
3.分别遍历两个数组

/* 本道题所需要的技术点
		 *  	1.数组
		 *  	2.循环结构、选择结构、变量
		 *  	3.循环结构、输出指令 
		 * 需求:去除数组中所有的数值0
	     *	1.定义一个数组oldArr，元素为13,4,5,0,0,6,6,0,5,4,7,6,7,0,5
		 *	2.去除所有为0的元素值，并存入到一个新的数组 newArr，
		 *	效果为1,34,5,6,6,5,4,7,6,7,53分别遍历两个数组
		 */
		// 1.定义一个数组oldArr，元素为13,4,5,0,0,6,6,0,5,4,7,6,7,0,5
		int[] oldArr = {1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5};
		
		// 2.去除所有为0的元素值，并存入到一个新的数组 newArr，
		// 获取新数组的长度（非0数值的数量）
		int newArrLength = 0;
		for (int num : oldArr) {
			if (num != 0) {
				newArrLength ++;
			}
		}
		// 创建新数组，存储非0数组
		int[] newArr = new int[newArrLength];
		int i = 0;
		for (int num : oldArr) {
			if (num != 0) {
				newArr[i] = num;
				i++;
			}
		}
		// 3.分别变量两个数组
		System.out.println("老数组" + Arrays.toString(oldArr));
		System.out.println("新数组" + Arrays.toString(newArr));
	}

互换值
需求:将指定数组元素值的位置前后互换，例如:[11,32，55, 47，79，23]置换后的数组元素为:[23,79,47,55,32,11]
1.定义一个整数数组arr
2.键盘录入5个整数，并存入数组arr3.定义一个新数组newArr
4.将指定数组arr的元素值的位置前后互换，并存储到新数组newArr中
5.在控制台分别横向打印 arr 和newArr的内容

/*本道题所需要的技术点
		 * 1.数组
		 * 2.输出指令、输入指令
		 * 3.数组
		 * 4.循环结构
		 * 5.输出指令、Arrays.toString(arr) //[元素1，元素2....]
		 * 
		 * 
		 * 需求:将指定数组元素值的位置前后互换，例如:[113255477923]置换后的数组元素为:[23,79,47,55,32,11]
	 	 * 	1定义一个整数数组arr
		 *   2.键盘录入5个整数，并存入数组arr
		 *	3定义一个新数组newArr
		 *	4.将指定数组arr的元素值的位置前后互换，并存储到新数组newArr 中
		 *	5在控制台分别横向打印arr和newArr的内容
		 */
		//	1定义一个整数数组arr
		int[] arr = new int[5];
		//   2.键盘录入5个整数，并存入数组arr
		Scanner input = new Scanner(System.in);
		for (int i = 0; i < arr.length; i++) {
			System.out.printf("请输入第%d个数字：", i+1);
			arr[i] = input.nextInt();
		}
		// 3定义一个新数组newArr
		int[] newArr = new int[arr.length];
		// 4.将指定数组arr的元素值的位置前后互换，并存储到新数组newArr 中
		for (int i = arr.length - 1, j = 0; i >= 0; i--, j++) {
			newArr[j] = arr[i];
			
		}
		// 5.输出
		System.out.println("老数组：" + Arrays.toString(arr));
		System.out.println("新数组：" + Arrays.toString(newArr));
	}

获取随机值
需求1:获取指定数组中随机的2个元素值1.定义一个int数组arr
2.键盘录入5个整数，存入数组arr中,并且录入之前提示输入的是第几个数字
3.随机获取数组中的两个元素值并在控制台打印

	/*本道题所需要的技术点
		 * 1.数组 
		 * 2.输出指令、输入指令
		 * 3.随机数、
		 * 	需求1:获取指定数组中随机的2个元素值
	 	 *	1定义一个int数组arr
		 *	2键盘录入5个整数，存入数组arr中并且录入之前提示输入的是第几个数字
		 *	3随机获取数组中的两个元素值并在控制台打印
		 */
		// 1定义一个int数组arr
		int[] arr = new int[5];
		
		// 2键盘录入5个整数，存入数组arr中并且录入之前提示输入的是第几个数字
		Scanner input = new Scanner(System.in);
		for (int i = 0; i < arr.length; i++) {
			System.out.printf("第%d个数字是：", i+1);
			arr[i] = input.nextInt();
		}
		// 3随机获取数组中的两个元素值并在控制台打印
		for (int i = 1; i <= 2; i++) {
			int randIndex = (int) (Math.random() * arr.length);
			System.out.println(arr[randIndex]);
		}
	}

需求2:随机获取4个A-Z之间(包含A和Z)的大写字母
1.定义一个char 数组arr
2.生成A-Z之间的26个大写字母，并存入数组arr中3.从arr数组中获取4个随机大写字母。

/*需求2:随机获取4个A-Z之间(包含A和Z)的大写字母
	 *	1.定义一个char数组arr
	 *	2生成A-Z之间的26个大写字母，并存入数组arr中
	 *3从arr数组中获取4个随机大写字母。
	 */
		// 1.定义一个char数组arr
		char[] arr = new char[26];
		
		// 2生成A-Z之间的26个大写字母，并存入数组arr中
		int i = 0;
		for (char alpha = 'A'; alpha <= 'Z'; alpha++) {
			arr[i] = alpha;
			i++;
		}
		// 3从arr数组中获取4个随机大写字母。
		for (int j = 1; j <= 4; j++) {
			int randIndex = (int) (Math.random() * arr.length);
			System.out.println(arr[randIndex]);
		}
	}

字符串的拼接
需求:获取指定字符数组中下标为奇数的所有字符，并连接成一个字符串
1.创建字符数组，数组包含26个大写字符及0-9字符
2.获取指定字符数组中,下标为奇数的所有字符，并连接成一个字符串
3.将字符串打印在控制台上

/*需求:获取指定字符数组中下标为奇数的所有字符并连接成一个字符串
	 *	1创建字符数组，数组包含26个大写字符及0-9字符
	 *	2.获取指定字符数组中，下标为奇数的所有字符，并连接成一个字符串
	 *	3将字符串打印在控制台上
	 *	
	 * 	烦死与字符串用+后拼接的 都变为字符串
	 */
		// 1创建字符数组，数组包含26个大写字符及0-9字符
		char[] arr = new char[36]; 
		// 储存26个大写字母
		int i = 0;
		for (char alpha = 'A'; alpha <= 'Z'; alpha++, i++) {
			arr[i] = alpha;
		}
		// 存储0-9字符
		for (char alpha = '0'; alpha <= '9'; alpha++, i++) {
			arr[i] = alpha;
		}
		// 2.获取指定字符数组中，下标为奇数的所有字符，并连接成一个字符串
		String str = "";
		for (int j = 0; j < arr.length; j++) {
			if (j % 2 != 0) {
				str += arr[j]; // str = str + arr[j]
			}
		}
		// 3将字符串打印在控制台上
		System.out.println(str);
	}