Java小练_数组

1.在歌唱比赛中，共有10位评委进行打分，在计算歌手得分时，去掉一个最高分，去掉一个最低分，然后剩余的8位评委的分数进行平均，就是该选手的最终得分。输入每个评委的评分，求某选手的得分。

		Scanner input = new Scanner(System.in);
		System.out.println("请问有几位评委：");
		int judgeNum = input.nextInt();	
		double totalScore = 0;
		int[] scores = new int[judgeNum];//把每次录入的分数动态存储起来
		//循环录入每个评委的分数
		for(int i=0;i<judgeNum;i++) {
			System.out.println("请录入第"+(i+1)+"个评委的分数：");
			int score = input.nextInt();
			scores[i] = score;
			totalScore += score;
		}
		int maxScore = scores[0];
		int minScore = scores[0];
		for(int sc:scores) {
			//结合三元运算符
			maxScore = (maxScore>sc)?maxScore:sc;
			minScore = (minScore<sc)?minScore:sc;
		}
		for(int index=1;index<judgeNum;index++) {
			maxScore = (maxScore>scores[index])?maxScore:scores[index];
			minScore = (minScore<scores[index])?minScore:scores[index];
		}
		System.out.println("歌手的最高得分："+maxScore);
		System.out.println("歌手的最低得分："+minScore);
		totalScore = totalScore-maxScore-minScore;
		double avg = totalScore/(judgeNum-2);
		System.out.println("去掉最高分和最低分之后，歌手的最终成绩为："+avg);

2.声明一个字符串的数组，空间为5个。使用循环接收五个学生的姓名。再使用循环输出这五个学生的姓名。

		String[] arr2 = new String[5];
		Scanner input = new Scanner(System.in);
		for(int i=0;i<5;i++) {
			System.out.println("请录入第"+(i+1)+"个学生的姓名：");
			String name = input.next();
			arr2[i] = name;
		}
		for(int index=0,len=arr2.length;index<len;index++) {
			System.out.println("第"+(index+1)+"个学生的姓名为："+arr2[index]);
		}

3.声明一个int型的数组，循环接收8个学生的成绩，计算这8个学生的总分、平均分、最高分、最低分。

		int[] arr3 = new int[8];
		Scanner input = new Scanner(System.in);
		int minScore = arr3[0];
		int maxScore = arr3[0];
		double totalScore = 0;
		for(int i=0;i<arr3.length;i++) {
			System.out.println("请录入第"+(i+1)+"个学生的成绩：");
			int score = input.nextInt();
			arr3[i] = score;
			totalScore += score;
		}
		double avgScore = totalScore/arr3.length;
		for(int sc:arr3) {
			minScore = (minScore<sc)?minScore:sc;
			maxScore = (maxScore>sc)?maxScore:sc;
		}
		for(int index=0,len=arr3.length;index<len;index++) {
			System.out.println("第"+(index+1)+"个学生的成绩为："+arr3[index]);
		}
		System.out.println("这8个学生的总分为："+totalScore);
		System.out.println("这8个学生的平均分为："+avgScore);
		System.out.println("这8个学生中的最高分为："+maxScore);
		System.out.println("这8个学生中的最低分为："+minScore);

4.现在有如下一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; 要求将以上数组中的0项去掉，将不为0的值存入一个新的数组，生成新的数组为 int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5};

		int oldArr[] = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; 
		int[] newArr = new int[oldArr.length];//将oldArr数组的元素复制到一个新的数组中
		int index = 0;
		for(int i=0;i<oldArr.length;i++) {
			if(oldArr[i] != 0) {
				newArr[index] = oldArr[i];
				index++;
			}
		}
		newArr = Arrays.copyOf(newArr,index);//把筛选出来的不为0的元素复制到newArr中去		
		System.out.println("newArr="+Arrays.toString(newArr));//newArr=[1,3,4,5,6,6,5,4,7,6,7,5]

5.有一整数数组，{1,3,-1,5,-2}，将数据复制到新数组中，要求逆序输出新数组中的数，同时并将小于0的元素按0存储。

		int arr5[]= {1,3,-1,5,-2};
		int[] newArr = new int[arr5.length];
		//第一步：将原数组逆序处理
		for(int i=(arr5.length)/2;i>=0;i--) {
			int temp = arr5[i];
			arr5[i] = arr5[arr5.length-1-i];
			arr5[arr5.length-1-i] = temp;
		}
//		System.out.println("niArr="+Arrays.toString(arr5));	//niArr=[-2, 5, -1, 3, 1]
		//第二步：将小于0的元素按0存储
		for(int index=0;index<arr5.length;index++) {
			if(arr5[index]<0) {
				newArr[index] = 0;
			}else {
				newArr[index] = arr5[index];
			}
		}
		System.out.println("newArr="+Arrays.toString(newArr));	

参考答案是把小于0的条件结合在逆序循环中，看起来程序简化了些，我起初也是这个思路，但是我想用Arrays.toString()整个地输出数组，相当于索引也逆序了，而不是按照逆序每次输出一个，所以分开写了。

6.按要求输出数组。

		//6.int array [] = {2,432,5221,235,2,5352,1,53,5,3,5364,2,2,63,3533,2,53,532,532}; 
		//6.1.求所有元素和。 
		//6.2.输出所有奇数下标元素。如：array[1] 
		//6.3.输出所有元素中，值为奇数的。 
		//6.4.将所有元素乘二。 
		//6.5.将所有元素加到第一个元素中。 
		//6.6.将奇数索引位置元素存到B数组中
		//6.7.偶数元素存到C数组中
		//6.8.分别逆序输出B数组和C数组
		int[] nums = {2,432,5221,235,2,5352,1,53,5,3,5364,2,2,63,3533,2,53,532,532}; 
		int totalNum = 0;
		int[] newNums = new int[nums.length];
		int[] newNums2 = new int[nums.length];
		int[] b = new int[nums.length/2];//B数组的长度是nums.length/2
		int[] c = new int[nums.length];//C数组的长度暂定与原数组一致
		int bIndex = 0;
		int cIndex = 0;
		for(int index=0;index<nums.length;index++) {
			totalNum += nums[index];
			if(index%2 != 0) {
//				System.out.println("下标为奇数"+index+"的元素："+nums[index]);
				b[bIndex] = nums[index];
				bIndex++;
			}
			if(nums[index]%2 != 0) {
				System.out.println("值为奇数的元素："+nums[index]);
			}else {
				c[cIndex] = nums[index];
				cIndex++;
			}
			newNums[index] = nums[index]*2;//将所有元素乘2
			newNums2 = Arrays.copyOf(nums,nums.length);//复制原数组到新数组
			newNums2[0] = totalNum;
		}
		//此时c数组里是原数组nums的偶数元素，但是c数组的长度最初设置的与原数组nums一致，所以不为偶数的索引位置值为0
		//需要将这些值为0的元素删去。也就是合理化c数组的元素长度
		int cCount = 0;
		for(int num : c) {
			if(num!=0) {
				c[cCount] = num;
				cCount++;
			}
		}
		c = Arrays.copyOf(c, cCount);//将不等于0的元素拿出来给新的c数组
		System.out.println("6.1.所有元素和:"+totalNum);
		System.out.println("6.4.元素乘以2后的数组:"+Arrays.toString(newNums));
		System.out.println("6.5.将所有元素加到第一个元素后的数组:"+Arrays.toString(newNums2));
		System.out.println("6.6.含奇数索引位置元素的B数组:"+Arrays.toString(b));
		System.out.println("6.7.含偶数元素的C数组:"+Arrays.toString(c));
        System.out.print("6.8.逆序输出B数组:");
        for (bIndex = b.length-1; bIndex >= 0; bIndex--) {
            System.out.print(b[bIndex] + ",");
        }
        System.out.print("\n"+"6.8.逆序输出C数组:");
        for (cIndex = c.length-1; cIndex >= 0; cIndex--) {
        	System.out.print(c[cIndex] + ",");
        }

7.从键盘接受10个整数保存在数组中，将10个数中最大的与第一个元素交换，最小的与最后一个元素交换，其余元素位置不变，输出数组元素的值。

//7.从键盘接受10个整数保存在数组中，将10个数中最大的与第一个元素交换，最小的与最后一个元素交换，其余元素位置不变，输出数组元素的值		
		Scanner input = new Scanner(System.in);
		int[] array = new int[10];	
		int len = array.length;//初始化数组的元素数
		for(int index = 0;index < len;index++) {
			System.out.println("请录入第"+(index+1)+"个整数：");
			array[index] = input.nextInt();
		}
		System.out.println("交换之前："+Arrays.toString(array));
		int maxIndex = 0;//用maxIndex来记录最大的数的下标
		int minIndex = 0;//用minIndex来记录最小的数的下标
		int max = array[0];//用max来记录最大的元素
		int min = array[0];//用min来记录最小的元素
		int temp = 0;//初始化一个中间值方便交换元素
		for(int index = 0;index < len-1;index++) {
			min = (min<array[index])?min:array[index];//找出最大元素
			max = (max>array[index])?max:array[index];//找出最小元素
			if(min==array[index]) {
				minIndex = index;//找出最大元素的下标
			}
			if(max==array[index]) {
				maxIndex = index;//找出最小元素的下标
			}
		}
		//最大值与第一个元素交换
		temp = array[0];
		array[0] = max;
		array[maxIndex] = temp;
		//最小的与最后一个元素交换
		temp = array[len-1];
		array[len-1] = min;
		array[minIndex] = temp;
		System.out.println("交换之后："+Arrays.toString(array));

我没有考虑到如果数组中出现多个最大值/最小值的情况，参考答案写的很全面，而且做题思路不一样。

我更换位置的思路是找到最大元素和最小元素的下标，然后通过更换下标来更换位置，而参考答案的做题思路是先用Arrays.sort()把数组从小到大排序，这样最大值自然在最后，最小值在最前，更换首位的元素值即可，不更改下标值。

比较赞同参考答案的做法，更换下标值容易逻辑混乱，换着换着就迷糊了。

考虑两个特殊情况：最大值与最小值正好在首尾；数组的元素中有多个最大值或者最小值的问题。

		//参考答案
		int[] array = {9,2,9,1,7,1,3};
		int len = array.length;
		System.out.println("交换之前："+Arrays.toString(array));
		int[] newArray = Arrays.copyOf(array, len);
		Arrays.sort(newArray);// 排序方法，顺序从小到大
		int maxIndex = 0;
		int minIndex = 0;
		int max = newArray[len-1];//最大值
		int min = newArray[0];//最小值
		int temp = 0;
		//特殊的情况一：
		//最大值与最小值正好在首尾 最小值:array[0] 最大值 = array[len-1] 直接让首尾元素做交换
		if(max == array[len-1] && min == array[0]) {
			//第一个元素与最后一个元素进行交换
			array[len-1] = min;
			array[0] = max;
			System.out.println("交换之后:" + Arrays.toString(array));
			return;
		}
		//特殊情况二：
		//数组的元素中 有多个最大值或者最小值的问题(与第一个最值出现的位置进行交换)
		//if逻辑的判断有且执行一次的
		int maxCount = 0;//充当最大值出现的次数
		int minCount = 0;//充当最小值出现的次数
		for(int index=0;index<len;index++) {
			if(max == array[index]) {
				maxCount++;
				if(maxCount>1) {
					continue;
				}
				maxIndex = index;
			}
			if(min == array[index]) {
				minCount++;
				if(minCount>1) {
					continue;
				}
				minIndex = index;
			}
		}
		//交换放循环外面，只一次交换，提高效率
		//最大值与第一个元素交换
		temp = array[0];
		array[0] = max;
		array[maxIndex] = temp;
		//最小的与最后一个元素交换
		temp = array[len-1];
		array[len-1] = min;
		array[minIndex] = temp;
		System.out.println("交换之后："+Arrays.toString(array));

输出结果：
交换之前：[9, 2, 9, 1, 7, 1, 3]
交换之后：[9, 2, 9, 3, 7, 1, 1]