冒泡排序以及Arrays函数及其二维数组的格式与应用

冒泡排序

用冒泡排序对数组[11,56,78,46,91,23,57,45]进行排序。

1. 外层for循环控制比较轮数（相当于原来的行数）
2. 内层for循环控制每一轮的比较次数（相当于原来每一行中的列数）
3. 然后比较相邻的两个元素，如果前面的元素比后面的元素大，交换元素位置

package cn.bdqn.demo01;

public class Demo01 {
	public static void main(String[] args) {
		
		int[] nums = {11,56,78,46,91,23,57,45};
		
		System.out.println("---排序前的数组---");
		for (int i = 0; i < nums.length; i++) {
			System.out.print(nums[i]+" ");
		}
		System.out.println();
		
		
		//外层for循环控制比较轮数（相当于原来的行数）
		for(int i =0;i<nums.length-1;i++){
			//内层for循环控制每一轮的比较次数（相当于原来每一行中的列数）
			for(int j =0;j<nums.length-1-i;j++){
				//比较相邻的两个元素，如果前面的元素比后面的元素大，交换元素位置
				if(nums[j]>nums[j+1]){
					int temp = nums[j];
					nums[j]=nums[j+1];
					nums[j+1]=temp;
				}
			}
		}
		
		System.out.println("---排序后的数组---");
		for (int i = 0; i < nums.length; i++) {
			System.out.print(nums[i]+" ");
		}

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

**练习一：**输入5位同学的成绩，并进行排序。

package cn.bdqn.demo01;

import java.util.Scanner;

public class Demo02 {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		
		//准备一个长度为5的double类型的数组用来存放5个学生的成绩
		double[] scores = new double[5];
		
		for (int i = 0; i < scores.length; i++) {
			System.out.println("请输入第"+(i+1)+"个同学的成绩：");
			scores[i]=sc.nextDouble();
		}
		
		System.out.println("排序前的成绩：");
		for (int i = 0; i < scores.length; i++) {
			System.out.print(scores[i]+" ");
		}
		System.out.println();
		
		//进行降序排序
		//外层循环控制比较轮数
		for (int i = 0; i < scores.length-1; i++) {
			//内层循环控制每一轮的比较次数
			for (int j = 0; j < scores.length-1-i; j++) {
				//比较相邻的两个数据，如果前面的数据比后面的数据小，交换位置
				if(scores[j]<scores[j+1]){
					double temp = scores[j];
					scores[j] = scores[j+1];
					scores[j+1]=temp;
				}
			}
		}
		
		System.out.println("排序后的成绩：");
		for (int i = 0; i < scores.length; i++) {
			System.out.print(scores[i]+" ");
		}

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

Arrays函数

• Arrays.sort(nums);是util包里面的Arrays;函数，其作用是进行数组升序排序。

练习二：对数组[11,56,78,96,123,45,36,63,72,10,88,86,77,44]进行升序排序。

package cn.bdqn.demo02;

import java.util.Arrays;

public class Demo01 {

	public static void main(String[] args) {
	
		int[] nums = {11,56,78,96,123,45,36,63,72,10,88,86,77,44};
		
		System.out.println("-----数组排序前-----");
		for (int i = 0; i < nums.length; i++) {
			System.out.print(nums[i]+" ");
		}
		System.out.println();
		
		//数组升序排序
		Arrays.sort(nums);
		
		
		System.out.println("-----数组排序后-----");
		for (int i = 0; i < nums.length; i++) {
			System.out.print(nums[i]+" ");
		}
		System.out.println();
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

Arrays.equals(数组名1,数组名2)

比较两个数组是否相同，返回一个布尔值，如果两个数组相同，返回true，否则返回false

boolean result1 = Arrays.equals(nums1, nums2);
System.out.println(“nums1数组和nums2数组相同：” + result1);

Arrays.toString(数组名)

将数组转换成字符串

String result2 = Arrays.toString(nums1);
System.out.println(result2);// [11, 22, 33, 44, 55]

Arrays.fill(数组名,数据)

将数组中的所有元素值替换为你指定的值

Arrays.fill(nums2, 99); System.out.println(Arrays.toString(nums2));//
[99, 99, 99, 99, 99]

Arrays.copyOf(数组名,复制长度)

将某个数组进行指定长度的复制

int[] newNums1 = Arrays.copyOf(nums1, 3);
System.out.println(Arrays.toString(newNums1));// [11, 22, 33]

int[] newNums2 = Arrays.copyOf(nums1, 5);
System.out.println(Arrays.toString(newNums2));// [11, 22, 33, 44, 55]

int[] newNums3 = Arrays.copyOf(nums1, 8);
System.out.println(Arrays.toString(newNums3));// [11, 22, 33, 44, 55, 0,]
1
2
3
4
5
6
7
8

Arrays.binarySearch(查找的数组名称,你想要查找的值)

在指定的数组中查找你要找的数据，返回这个数据的下标，如果找不到这个值，返回一个负值。使用这个方法之前，要确保数组进行了排序，否则不能保证查询结果的正确性

int[] number = { 11, 55, 69, 34, 78, 16, 84 };
Arrays.sort(number);
System.out.println(Arrays.toString(number));// [11, 16, 34, 55, 69, 78,84]

int index = Arrays.binarySearch(number, 78);
System.out.println("你要查找的数据下标：" + index);
1
2
3
4
5
6

练习三：要求对3个班各6名学生某门课程的成绩进行各种操作，如何实现？

1. 可以定义3个长度为6的数组
2. 求每个班的成绩之和与平均成绩

package cn.bdqn.demo03;

public class Demo01 {

	public static void main(String[] args) {
		double[] scores1 = { 95, 56, 78, 99, 88, 66 };
		double[] scores2 = { 85, 56, 88, 99, 78, 56 };
		double[] scores3 = { 95, 96, 98, 99, 80, 76 };

		// 求每个班的成绩之和与平均成绩
		double sum1 = 0;
		for (int i = 0; i < scores1.length; i++) {
			sum1 += scores1[i];
		}
		double avg1 = sum1 / 6;
		System.out.println("第1个班的成绩之和：" + sum1);
		System.out.println("第1个班的平均成绩：" + avg1);

		double sum2 = 0;
		for (int i = 0; i < scores2.length; i++) {
			sum2 += scores2[i];
		}
		double avg2 = sum2 / 6;
		System.out.println("第2个班的成绩之和：" + sum2);
		System.out.println("第2个班的平均成绩：" + avg2);

		double sum3 = 0;
		for (int i = 0; i < scores3.length; i++) {
			sum3 += scores3[i];
		}
		double avg3 = sum1 / 6;
		System.out.println("第3个班的成绩之和：" + sum3);
		System.out.println("第3个班的平均成绩：" + avg3);

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

二维数组

二维数组：本质上还是一个一维数组，只是这个一维数组里的元素还是一个一维数组

二维数组声明

数据类型[][] 数组名; 或者 数据类型 数组名[][];

int[][] nums;
String[][] strs;
1
2

分配空间

数组名 = new 数据类型[数组长度][数组长度]; 或 数组名 = new 数据类型[数组长度][];

nums = new int[3][5];// nums是一个长度为3的二维数组，这个二维数组里的元素都是一个长度为5的一维数组
strs = new String[5][]; // strs是一个长度为5的二维数组，这个二维数组里的元素长度不相同
1
2

赋值

数组名[下标][下标] = 数据;

nums = new int[3][5];
nums[0][0] = 10;
nums[0][1] = 20;
nums[0][2] = 30;
nums[0][3] = 40;
nums[0][4] = 50;
		
nums[1][0] = 100;
nums[1][1] = 200;
nums[1][2] = 300;
nums[1][3] = 400;
nums[1][4] = 500;
		
nums[2][0] = 10;
nums[2][1] = 20;
nums[2][2] = 30;
nums[2][3] = 40;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

操作数据

数组名[下标][下标]

System.out.println(nums[1][2]);
nums[2][0]+=50;
System.out.println(nums[2][0]);
1
2
3

二维数组声明、分配空间合并写

方法一：数据类型[][] 数组名 = new 数据类型[长度][长度];
方法二：数据类型[][] 数组名 = new 数据类型[长度][];

int[][] nums = new int[3][4];
char[][] chs = new char[5][];

二维数组声明、分配空间、赋值合并写

数据类型[][] 数组名 = new 数据类型[][]{{数据1,数据2,…,数据n},{数据1,数据2,…,数据m},…,{数据1,数据2,…,数据k}};

boolean[][] bools = new boolean[][]{{true},{true,false},{false,false,true,false}};
1

二维数组声明、分配空间、赋值合并写的简写方式

数据类型[][] 数组名 = {{数据1,数据2,…,数据n},{数据1,数据2,…,数据m},…,{数据1,数据2,…,数据k}};

float[][] floats ={{12.5F},{99.5F,55.5F},{99.9F},{10.5F,12.5F,85.5F,56.3F,78.5F}};
1

练习四：要求对3个班各6名学生某门课程的成绩进行各种操作，如何实现？

package cn.bdqn.demo03;

public class Demo04 {

	public static void main(String[] args) {
		// 声明一个长度为3的二维数组，这个二维数组里的元素都是长度为6的一维数组
		int[][] scores = { { 99, 86, 75, 94, 45, 60 },
				{ 100, 78, 55, 86, 94, 30 }, { 100, 99, 88, 66, 77, 89 } };

		// 遍历这个二维数组
		for (int i = 0; i < scores.length; i++) {
			// System.out.println(scores[i]);//scores[i]还是一个一维数组，这个一维数组里存储的是各个班级学生的成绩，输出scores[i]输出的是这个一维数组的地址值，我们需要将这个一维数组里的元素取出来

			// 声明一遍变量来累加各个班的成绩之和：
			int sum = 0;
			System.out.println("第" + (i + 1) + "个班学生成绩分别是：");
			for (int j = 0; j < scores[i].length; j++) {
				System.out.print("第" + (j + 1) + "名学生成绩：");
				System.out.println(scores[i][j]);
				sum += scores[i][j];
			}
			System.out.println("第" + (i + 1) + "个班学生成绩之和是：" + sum);
			int avg = sum / scores[i].length;
			System.out.println("第" + (i + 1) + "个班学生平均成绩是：" + avg);
		}

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30