本文详细介绍了Java中的一维数组，包括数组的定义、初始化、赋值机制、拷贝、反转、添加和缩减操作。此外，还讲解了排序的基本概念，冒泡排序以及查找的基本分类。同时，对二维数组进行了深入探讨，如动态初始化和静态初始化，以及多维数组的使用细节和注意事项。最后，提供了丰富的课堂练习和本章作业，帮助读者巩固所学知识。
一、一维数组
1、数组
-
（1）、介绍
数组是可以存放 多个 同一类型 的数据。数组也是一种数据类型，是引用类型
即：数组就是一组数据
-
（2）、定义
数据类型 数组名[] = new 数据类型[大小] /// 数据类型 [] 数组名 = new 数据类型[大小] //数组下标范围是 0 ~ 大小 - 1
例如：
int a[] = new int[5]; //int[] a = new int[5]; //创建了一个数组，数组能够存放 5 个 int型 数据 -
（3）、引用 数组名[下标/索引]
例如：输入 5 个成绩，保存到 double 数组，并输出double [] score = new double[5]; Scanner scanner = new Scanner(System.in); for(int i = 0;i < 5;i++){ System.out.println("请输入第 " + (i + 1) + " 个成绩"); score[i] = scanner.nextDouble(); } for(int i = 0;i < score.length;i++){ System.out.println("第 " + (i + 1) + " 个成绩为：" + score[i]); }
2、数组初始化
（1）、静态初始化
-
语法：数据类型 数组名 [] = {元素值1,元素值2,…} 或
数据类型[] 数组名 = {元素值1,元素值2,…} 或
数据类型[] 数组名 = new 数据类型[]{元素值1,元素值2,…}
（如果数组的内容不确定，则需要一个一个赋值）
例如：
int a[] = {1,2,4,3,6,5,4,8}; // 这种用法适用于知道具体的元素
（2）、动态初始化
-
1）、先声明数组
语法：
数据类型 数组名[] /// 数据类型[] 数组名例如：
int a[]; /// int[] a; -
2）、再创建数组
语法：数组名 = new 数据类型[大小];例如：
a = new int[10];例如：
double [] score; score = new double[5];
3、注意事项和使用细节
-
1)、数组是多个 相同类型元素 的组合，实现对这些数据的统一管理
例如：int []a = {1，2，3，4，5.5}; //这样是不行的 相当于把一个 double型 数据 的值赋给了 int型数据 //但是满足自动类型转换的 就可以 -
2)、数组中的元素类型可以是任何数据类型，但是不能混，一定要保证类型匹配
-
3)、数组创建后，如果没有赋值，则系统会给数组自动赋初值
int short byte long 都是 0 float double 都是 0.0 char 是 \u0000 boolean 是 false String 是 null -
4)、数组的使用步骤是 先声明并开辟空间；给数组各个元素赋值；最后再使用数组
-
5)、数组的下标是从 0 开始的
-
6)、数组的下标必须在指定范围内使用，否则会下标越界异常/错误 ，数组的下标范围是 0 ~ 数组长度-1
-
7)、数组是引用类型，数组型数据都是对象（object）
4、课堂练习
-
（1）、创建一个 char型 26个元素的数组，分别放置 A - Z ，使用 for 访问所有元素并打印
//char 类型运算 'A' + 2 = 'C'; char[] chars = new char[26]; for(int i = 0; i < 26; i++){ chars[i] = (char) ('A' + i);//因为'A' + i 运算结果是 int型，不能赋值给 char型，一定要有强制转换 } for(int i = 0; i < chars.length; i++){ System.out.print(chars[i] + " " ); } -
（2）、求出一个数组的最大值，并知道对应下标
//思路：定义一个 max存储最大值 ，再定义一个 maxIndex 存储位置 // 假定最大值是第一个元素，如果 max < 当前元素，则赋值替换，一直遍历到结束 int [] a = {4,-1,9,10,333}; int max = a[0]; int maxIndex = 0; for(int i = 1; i < a.length; i++){ if(max < a[i]){ max = a[i]; maxIndex = i; } } System.out.print("max = " + max + " maxIndex = " + maxIndex); //输出 max = 333 maxIndex = 4 -
（3）、求出一个数组的平均值
//用数组长度遍历求和取平均 double [] a = {4,-1,9,10,333}; double ave = 0; double sum = 0; for(int i = 1; i < a.length; i++){ sum += a[i]; } ave = sum / a.length; System.out.println(" ave = " + ave ); //输出 ave = 70.2
5、数组的赋值机制
-
（1）、基本数据类型赋值，这个值就是具体的数据，而且互相不影响
// 赋值方式为值拷贝 这里用到了两个地址来存储数据，所以互不影响
int a1 = 1; int a2 = a1; //此时，a1 = 1; a2 = 1; //当 a2 = 2; 时，a1 仍然是 1； -
（2）、在默认情况下是引用传递，赋值的是地址
// 赋值方式为引用传递，赋的值是地址,因为读取值是读取地址中存储的数据，
// 下面的 a1[] 读取值实质上是在读取地址,而且这个地址 两个数组都可以操作，
// 改值本质上是改动地址中的值，并没有改变这个地址
// 所以一个操作使得地址中的值修改之后
// 另一个访问之后也能看到修改
//看一个案例，并分析数组赋值的内存图 int[] a1 = new int[3]; int[] a2 ={1,2,3}; a1 = a2; //此时，a1 = {1,2,3}; a2 = {1,2,3}; //当 a2[0] = 10; 时，a1[0] 也就随之变成了10， a1[1] =10; a2[0] = 10; for(int i = 0; i < a1.length; i++){ System.out.print( a1[i]); } System.out.println( ); for(int i = 0; i < a2.length; i++){ System.out.print( a2[i]); } -
内存分析图
6、数组的拷贝（内容复制，不是地址复制，要求数据空间是独立的）
int[] arr1 ={10,20,30};
int[] arr2 = new int[arr1.length];
//遍历一遍 arr1，把元素拷贝到 arr2 中
for(int i = 0; i < arr1.length; i++){
arr2[i] = arr1[i];
}
arr1[1] = 100;
for(int i = 0; i < arr1.length; i++){
System.out.print( arr1[i] );
}
System.out.println();
for(int i = 0; i < arr1.length; i++){
System.out.print( arr2[i] );
}
//这样复制之后，两个数组的数值改变就不互相影响了
7、数组反转，要求把数组的元素内用反转 {1，2，3，4，5} --> {5，4，3，2，1}
//思路：新建一个数组，从尾部开始遍历原始数组，然后把数值原数组的值逆着放入新的数组中
// 再把这个新建立的数组赋值给原来的数组即可
int[] arr1 ={1,2,3,4,5};
int[] arr2 = new int[arr1.length];
for(int i = arr1.length-1, j = 0; i >= 0 && j < arr1.length; i--,j++){
arr2[j] = arr1[i];
}
for(int j =0; j < arr1.length; j++){
System.out.print( arr1[j] );//12345
}
System.out.println();
for(int j =0; j < arr1.length; j++){
System.out.print( arr2[j] );//54321
}
for(int j =0; j < arr1.length; j++){
arr1[j] = arr2[j];
}
System.out.println();
for(int j =0; j < arr1.length; j++){
System.out.print( arr1[j] );//54321
}
//思路
//把第一个和最后一个交换
//把第二个和倒数第二个交换
//一共要交换 arr1.length / 2 = 3 次
//每次交换时，对应下标是 arr1[i] 和 arr[arr.length - 1 -i]
int[] arr1 ={1,2,3,4,5};
int[] arr2 = new int[arr1.length];
for(int i = 0;i < (arr1.length) / 2; i++){
int temp = arr1[arr1.length-1 - i];
arr1[arr1.length-1 -i] = arr1[i] ;
arr1[i] = temp;
}
for(int j =0; j < arr1.length; j++){
System.out.print( arr1[j] );//54321
}
//可以进行代码优化 arr.length --> len,temp 定义放在外面
int[] arr1 ={1,2,3,4,5};
int len = arr1.length;
int[] arr2 = new int[len];
int temp;
for(int i = 0;i < (len) / 2; i++){
temp = arr1[len - 1 - i];
arr1[len-1 -i] = arr1[i] ;
arr1[i] = temp;
}
for(int j =0; j < len; j++){
System.out.print( arr1[j] );//54321
}
8、数组添加：实现动态给数组添加元素，实现对数组的扩容
- （1）、原始数组使用静态分配 int[] arr = {1,2,3};
- （2）、课堂练习①：增加的元素 4 直接放在数组的最后，arr = {1,2,3,4}; arr_New = {1,2,3,4};
//思路 //定义初始数组 int[] arr = {1,2,3}; //定义一个新的数组int[] arr_New = new int[arr.length + 1] ; //遍历原始数组 arr，将数据拷贝到新数组 arr_New //再将新的元素赋值给 arr_New[arr_New.length - 1] //最后让 arr 指向 --> arr_new;arr = arr_New;那么 最原始的 arr 数组就自动被系统自动回收垃圾系统销毁了 int[] arr1 ={1,2,3,4,5}; int[] arrNew = new int[arr1.length + 1]; for(int i =0; i < arr1.length; i++){ arrNew[i] = arr1[i]; } arrNew[arrNew.length -1] = 6; arr1 = arrNew; for(int i =0; i < arr1.length; i++){ System.out.print( arr1[i] );//123456 } - （3）、课堂练习②：用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？ y / n
//创建一个 scanner 接收用户输入 //因为不确定用户什么时候退出 使用 do while + break 来完成控制 int[] arr1 ={1,2,3,4,5}; Scanner scanner = new Scanner(System.in); do{ int[] arrNew = new int[arr1.length + 1]; for(int i =0; i < arr1.length; i++){ arrNew[i] = arr1[i]; } System.out.println("请输入你要添加的数："); int receiceInt = scanner.nextInt(); arrNew[arrNew.length -1] = receiceInt; arr1 = arrNew; System.out.println("输入之后的数组为"); for(int i =0; i < arr1.length; i++){ System.out.println( arr1[i] + " " ); } //询问用户是否继续 System.out.println("你还想继续吗？ \n输入 y 继续,输入 n 退出"); char receiceChar = scanner.next().charAt(0); if(receiceChar == 'n'){ break; } }while(true ); System.out.println("你退出了继续输入...");
9、数组缩减：实现动态给数组减少元素，实现对数组的缩减
-
（1）、原始数组使用静态分配 int[] arr = {1,2,3};
-
（2）、课堂练习①：直接把原来数组的最后一个元素删了arr = {1,2,3,4}; arr_New = {1,2,3};
//思路 //定义初始数组 int[] arr = {1,2,3}; //定义一个新的数组int[] arr_New = new int[arr.length - 1] ; //遍历原始数组 arr，将数据拷贝到新数组 arr_New，for循环判断条件是 i < arr.length - 1 //最后让 arr 指向 --> arr_new;即arr = arr_New;那么 最原始的 arr 数组就自动被系统自动回收垃圾系统销毁了 -
（3）、课堂练习②：用户可以通过如下方法来决定是否继续删减，添加成功，是否继续？ y / n
//创建一个 scanner 接收用户输入 //因为不确定用户什么时候退出 使用 do while + break 来完成控制 int[] arr1 ={1,2,3,4,5}; Scanner scanner = new Scanner(System.in); do{ int[] arrNew = new int[arr1.length - 1]; for(int i =0; i < arr1.length - 1; i++){ arrNew[i] = arr1[i]; } arr1 = arrNew; System.out.println("删减之后的数组为："); for(int i =0; i < arr1.length; i++){ System.out.print( arr1[i] + " " );//123456 } //询问用户是否继续 System.out.println("你还想继续吗？ \n输入 y 继续,输入 n 退出"); char receiceChar = scanner.next().charAt(0); if(receiceChar == 'n'){ break; } }while(true ); System.out.println("你退出了继续删减...");
二、排序
1、分类
-
内部排序：指将需要处理的所有数据都加载到内存中进行排序，包括（冒泡、选择、插入）式排序法
-
外部排序；数据量过大，无法全部加载到内存中，需要借助外部存储进行排序，包括（合并排序法、直接合并法）
2、冒泡排序：
通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的值，若发现逆序交换，使值较大的元素逐渐移向后部，像冒泡泡一样
例如：使用冒泡排序 从小到大排序 24，69，80，57，13
//思路
//数组 {24，69，80，57，13}
//第一轮：目标把 最大 数放在最后
//第一次比较 24，69 无动作
//第二次比较 68，80 无动作
//第三次比较 80，57 二者交换，交换完了之后数组为 {24，69，57，80，13}
//第四次比较 80，13 二者交换，交换完了之后数组为 {24，69，57，13，80}
//这 4 次比较就确定了最大数
//第二轮：目标把 第二大 数放在倒数第 二 位
//第一次比较 24，69 无动作
//第二次比较 69，57 二者交换，交换完了之后数组为 {24，57，69，13，80}
//第三次比较 69，13 二者交换，交换完了之后数组为 {24，57，13，69，80}
//第四次比较 69，80 无动作 //只需要进行前三步即可
//第三轮：目标把 第三大 数放在倒数第 三 位
//第一次比较 24，57 无动作
//第二次比较 57，13 二者交换，交换完了之后数组为 {24，13，57，69，80}
//第三次比较 57，69 无动作
//第四次比较 69，80 无动作 //只需要进行前两步即可
//第四轮：目标把 第四大 数放在倒数第 四 位
//第一次比较 24，13 二者交换，交换完了之后数组为 {13，24，57，69，80}
//第二次比较 24， 57 无动作
//第三次比较 57，69 无动作
//第四次比较 69，80 无动作 //只需要进行第一步即可
//第五轮：目标把 第五大 数放在倒数第 五 位
//第一次比较 13，24 无动作
//第二次比较 24，57 无动作
//第三次比较 57，69 无动作
//第四次比较 69，80 无动作//由此看来，第五轮，没有必要
//总结，一共有 5 个数，要进行 5 - 1 轮，每轮比较数目 = 总个数 - 当前轮数
//所以，每一轮排序 可以看成时外层循环，每轮的比较 可以看成是内循环
//第 N 轮就能够确定第 N 大的数的 位置 为 倒数第 N
//进行比较时，如果前面的数 大于 后面的数，就交换
int[] arr ={24,69,80,57,13};
int temp = 0;
for(int i =0; i < arr.length - 1; i++){
for(int j =0; j < arr.length - i - 1; j++){
if(arr[j] > arr[j+1]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for(int i =0; i < arr.length; i++){
System.out.print( arr[i] + " " );
}
//13 24 57 69 80
三、查找
1、分类
顺序查找、二分查找（后面讲）
2、案例演示
有一个数列：白眉鹰王、金毛狮王、青翼蝠王、紫衫龙王 猜数游戏：
从键盘中任意输入一个名称，判断数列中是否包含此名称（顺序查找）
要求：如果找到了，就提示找到了，并提供下标值
//思路
//先定义一个字符串数组来保存上述四个王
//再定义一个数来保存下标位置 初始值为 -1
//提示用户进行输入并接收输入
//遍历数组，查看是否 在里面，如果在里面，则输出，并且记录 index的值，如果不在index 的值不改变
String[] king = {"白眉鹰王","金毛狮王","青翼蝠王","紫衫龙王"};
int kingIndex = -1 ;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要找的王 ");
String name = scanner.next();
for(int i =0; i < king.length; i++){
if(name.equals(king[i])){
kingIndex = i;
System.out.println("找到了 " + king[i] );
System.out.println("下标是 " + kingIndex );
break;
}
}
if(kingIndex == -1){ //就说明，if语句块根本就没有进入
System.out.println("没有找到" );
}
四、多维数组：二维数组
1、快速输出以下图形
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
- 原始方法：定义五个一维数组，然后再把对应的值放进对应数组，最后再打印
- 新方法 ：定义一个二维数组 int[][] arr = {{0,0,0,0,0,0},{0,0,1,0,0,0},{0,2,0,3,0,0},{0,0,0,0,0,0}};
//可以这样理解：二维数组的元素是一个 一维数组,如果需要得到一维数组的值，还需要再次遍历
int[][] arr = {{0,0,0,0,0,0},{0,0,1,0,0,0},{0,2,0,3,0,0},{0,0,0,0,0,0}};
for(int i = 0; i < arr.length; i++){ //arr.length 得到 二维数组的行数
for(int j = 0; j < arr[i].length; j++){ //arr[i].length 得到 每一行的列数
System.out.print(arr[i][j] + " ");
//访问第 i 个一维数组的 第 j 个元素 : arr[i - 1][j - 1]
}
System.out.println();
}
2、动态初始化 - 1
- 语法：
数据类型 [][] 数组名 = new 数据类型[大小][大小] 数据类型 数组名[][] = new 数据类型[大小][大小] - 例如：
int a[][] = new int[3][3]; int[][] a = new int[3][3]; int[] a[] = new[3] int[3]; //三者本质上是一样的，只是书写方法不同
3、动态初始化 - 2
- 语法：先声明，在定义（开辟空间），最后赋值
数据类型 数组名[][]; 数组名 = new 数据类型[大小][大小]; 赋值（有默认值，这跟之前说的默认值一致）;
4、动态初始化 - 3：解决列数不确定的情况
-
使用演示
//要求输出 //1 //2 2 //3 3 3 //思路分析： //它列数不确定，我们可以先确定行数，Java中二维数组 定义行数必须有，列数可以没有 //定义一个Scanner 对象，一个int型 数据 row 来存储接收到的行数 //然后 动态初始化数组， int[][] arr = new int[row][]; //遍历这个二维数组的行，对每一行进行一个赋值操作，其实就是操作列 //进行操作的时候，要给每个列开辟空间，要不然报 空指针错误 //即： for(int i = 0; i < arr.length; i++){ for(int j = 0; j < i; j++){ arr[i][j] = i; } } //具体代码 Scanner scanner =new Scanner(System.in); int row = 0; System.out.println("请输入想要创建的行数"); row = scanner.nextInt(); int[][] arr = new int[row][]; //创建二维数组，给行创建了空间，但是只是声明了列，没给列创建空间 for(int i = 0; i < arr.length; i++){ arr[i] = new int[i + 1];//到这里才给每一列开辟空间，大小正好是 行数 +1 for(int j = 0; j < i + 1; j++){ arr[i][j] = i + 1; } } //遍历整个二维数组 System.out.println("得到的数组为："); for(int i = 0; i < arr.length; i++){ //arr.length 得到 二维数组的行数 for(int j = 0; j < arr[i].length; j++){ //arr[i].length 得到 每一行的列数 System.out.print(arr[i][j] + " "); //访问第 i 个一维数组的 第 j 个元素 : arr[i - 1][j - 1] } System.out.println(); } //输出 //请输入想要创建的行数 //5 //得到的数组为： //1 //2 2 //3 3 3 //4 4 4 4 //5 5 5 5 5
5、静态初始化
- 语法：
数据类型 [][] 数组名 = {{值1,值2,..},{值1,值2,..},{值1,值2,..}}; 数据类型 数组名[][] = {{值1,值2,..},{值1,值2,..},{值1,值2,..}}; - 定义之后直接使用就行
- 例如
int[][] arr = {{1,1,1},{5,5,1},{0}}; //虽然二维数组最后一个元素只有 1个值， //{}依然不可以拿掉，否则类型不匹配：引用类型 --> 数据类型
6、课堂练习
-
（1）、遍历该二维数组，并求总和 int[][] arr = {{6,4},{7,5,1},{-2}};
int sum = 0; int[][] brr = {{6,4},{7,5,1},{-2}}; for(int i = 0; i < brr.length; i++){ //arr.length 得到 二维数组的行数 for(int j = 0; j < brr[i].length; j++){ //arr[i].length 得到 每一行的列数 sum += brr[i][j]; } } System.out.println(sum); //输出 21 -
（2）、打印一个杨辉三角
// 思路分析： // 第 n 行 有 n 个数，即 第 n 行有 n 列 ，一个一维数组 // 每一行第一个元素和最后一个元素都为1 // 从第三行开始，对于非第一个元素和最后一个元素的值为它的正上方的值和正上方左边的值 // 即：arr[i][j] = arr[i-1][j] + arr[i - 1][j -1] // 定义一个Scanner 对象，一个int型 数据 row 来存储接收到的杨辉三角的行数，这也是二维数组的行数 Scanner scanner =new Scanner(System.in); int row = 0; System.out.println("请输入想要创建的行数"); row = scanner.nextInt(); int[][] arr = new int[row][]; //创建二维数组，给行创建了空间，但是只是声明了列，没给列创建空间 for(int i = 0; i < arr.length; i++){ arr[i] = new int[i + 1];//到这里才给每一列开辟空间，大小正好是 行数 +1 for(int j = 0; j < arr[i].length; j++){//给每个一维数组赋值 if(j == 0 || j == arr[i].length - 1){//一定要注意 第一个元素下标是0吗，最后一个元素下标是 .length - 1 arr[i][j] = 1; //否则就会指针溢出报错 }else { arr[i][j] = arr[i-1][j] + arr[i - 1][j -1]; } } } //遍历整个二维数组 System.out.println("得到的数组为："); for(int i = 0; i < arr.length; i++){ //arr.length 得到 二维数组的行数 for(int j = 0; j < arr[i].length; j++){ //arr[i].length 得到 每一行的列数 System.out.print(arr[i][j] + "\t"); //访问第 i 个一维数组的 第 j 个元素 : arr[i - 1][j - 1] } System.out.println(); } //请输入想要创建的行数 //5 //得到的数组为： //1 //1 1 //1 2 1 //1 3 3 1 //1 4 6 4 1
7、使用细节和注意事项
-
1、一维数组的声明方式有 int[] a; int a[];
-
2、二维数组的声明方式有 int[][] y; int y[][];int[] y[]; //我推荐第一个
-
3、二维数组实际上是由多个一维数组组成的，它的各个一维数组长度可以相同，也可以不同，如果列数不完全相同，称之为 列数不等的二维数组
8、课堂练习
-
声明 int[] x,y[];以下选项能通过编译的是
//上面的这行代码的意思是 int[] x; int[] y[];
//所以定义了x 为一维数组，y 为二维数组
x[0] = y; //错，二维数组 y 无法赋值给一维数组 x
y[0] = x; //对，一维数组 x 可以赋值给二维数组 y
y[0][0] = x; //错，一维数组 x 无法赋值给二维数组 y 的具体元素
x[0][0] = y; //错，x 为一维数组
y[0][0] = x[0]; //对，一维数组 x 的具体元素 可以赋值给 二维数组
y 的具体元素x = y; //错，数组类型不匹配，无法赋值
五、本章作业
1、下面数组定义正确的有
String str[] = {"a","b","c"}; //ok ,
String[] str = {'a','b','c'}; //error ,char型 赋值给 String型，不通过
String[] str = new String{"a","b","c"}; //error ,
String[] str = new String[]{"a","b","c"}; //ok ,
String[] str = new String[3]{"a","b","c"};//error ,编译通不过
2、写出下列输出结果
String foo = "blue";
boolean[] bar = neww boolean[2];
if(bar[0]){
foo = "red";
}
System.out.println(foo);
//最终结果是 blue ,bar 这个数组，并没有赋值，系统给的整个数组的初始值是 false，无法进入 if
3、写出下列输出结果
int num = 1;
while(num < 10){
System.out.println(num);
if(num > 5){
break;
}
num += 2;
}
//输出
//1
//3
//5
//7
4、已知有一个升序数组，要求插入一个元素，该数组的顺序依然是升序，代码实现
- 例如：{10,12,45,90} 插入 20 -->{10,12,20,45,90}
- 第一种方法，正好插入正确的位置
//这道题很经典，多看看 //思路 //定义一个Scanner 对象，一个int型 数据 input 来存储要插入的数 //定义一个新的数组arrNew，该数组大小 为原始数组长度 + 1 ,即 arr.length + 1 //并且要记录一个数 index，来确定插入的位置，初始为 -1 ，表示为没有找到位置 //然后遍历这个原始一维数组arr，直到第一次 input < arr[i]，记录下位置 index = i(break),如果遍历arr完后，没有发现符合条件的，则自动把该数插入到数组最后 // 即 index = arr.length // index = arrNew.length -1 //位置确定之后，遍历一遍新数组 arrNew,来依次插入想要插入的值 input,要注意，input 只有在新数组arrNew 下标为index 这个位置插入 //其他的位置直接复制原数组arr 的值 //最后把新数组 指向 原来的数组 arr = arrNew; //输出 arr Scanner scanner =new Scanner(System.in); int input = 0; int index = -1; int[] arr = {10,12,45,90}; int[] arrNew = new int[arr.length + 1] ; System.out.println("原始数组为："); for(int i = 0; i < arr.length; i++){ System.out.print(arr[i] + " "); } System.out.println( ); System.out.println("请输入想要插入的数"); input = scanner.nextInt(); for(int i = 0; i < arr.length; i++){ if(arr[i] > input){ index = i;//确定插入的位置 break; //保证是第一次大于 } } if(index == -1){ //这就是说明没有在原数组 arr 中找到位置 index = arrNew.length - 1;//自动把该数插入到新数组arrNew最后 } //数组元素拷贝 for(int i = 0,j = 0; i < arrNew.length; i++){//遍历新数组arrNew，插入原数组arr 的数据 ; i 是新数组arrNew 的下标 if(index != i){ //如果要插入的位置index 不是当前位置 i，则插入原数组arr 的对应位置的值 arrNew[i] = arr[j]; j++; //j 对应的是原数组arr 的下标，当我要往新数组arrNew中插入input时，原数组的下标值j不能变动 //这样以来，插入过input的新数组arrNew的i+1下标的位置正好对应原数组arr的j下标，之后又是正常拷贝，可以在纸上画一画就出来了 }else{ //如果要插入的位置index 是当前位置 i，则插入要插入的值input arrNew[i] = input; } } arr = arrNew;//最后把新数组 指向 原来的数组 arr = arrNew; System.out.println("插入后的数组为："); for(int i = 0; i < arr.length; i++){ System.out.print(arr[i]+ " ");//打印新数组 } //原始数组为： //10 12 45 90 //请输入想要插入的数 //23 //插入后的数组为： //10 12 23 45 90 //原始数组为： //10 12 45 90 //请输入想要插入的数 //100 //插入后的数组为： //10 12 45 90 100 - 第二种方法，先扩容，直接插入到扩容后的新数组arrNew的最后，然后把新数组arrNew 指向 原来的数组arr，即 arr = arrNew;再对arr进行冒泡排序，最后输出arr
//思路 //定义一个Scanner 对象，一个int型 数据 input 来存储要插入的数 //定义一个新的数组arrNew，该数组大小 为原始数组长度 + 1 ,即 arr.length + 1 //进行数组拷贝，直接把原数组arr 拷贝到新数组 arrNew 中，再把插入的数 input插入到新数组arrNew的最后 //最后把新数组 指向 原来的数组 arr = arrNew; //对 arr进行冒泡排序 //输出 arr Scanner scanner =new Scanner(System.in); int input = 0; int[] arr = {10,12,45,90}; int[] arrNew = new int[arr.length + 1] ; System.out.println("原始数组为："); for(int i = 0; i < arr.length; i++){ System.out.print(arr[i] + " "); } System.out.println( ); System.out.println("请输入想要插入的数"); input = scanner.nextInt(); //数组元素拷贝 for(int i = 0; i < arr.length; i++){//遍历新数组arrNew，插入原数组arr 的数据 ; i 是新数组arrNew 的下标 arrNew[i] = arr[i]; } arrNew[arr.length] = input;//插入的数 input 放到 新数组arrNew的最后 arr = arrNew;//最后把新数组 指向 原来的数组 arr = arrNew; //冒泡排序 int temp = 0; for(int i =0; i < arr.length - 1; i++){ for(int j =0; j < arr.length - i - 1; j++){ if(arr[j] > arr[j+1]){ temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } System.out.println("插入后的数组为："); for(int i = 0; i < arr.length; i++){ System.out.print(arr[i]+ " ");//打印新数组 } //输出的结果是一样的
5、随机生成10个整数（1 - 100）保存到数组中，并倒叙打印求出其平均值，求最大值和最大值的下标，并查找里面是否存在 8
//随机生成10个整数（1 - 100）保存到数组中，并倒序打印求出其平均值，求最大值和最大值的下标，并查找里面是否存在 8
//思路：功能很多，不要急，慢慢来
//首先生成1 - 100 的随机整数，int(Math.random()*100 + 1)
//然后创建一个double类型的数组arr ，因为要计算平均值，只能是double，赋值也没问题，自动转换成立
//生成一个随机数，就把这个随机数放在数组arr 里面
//倒序数组，之前说过的，一个for循环，循环条件是i <(.length) / 2,第 [i] 个 和第 [.length- 1 - i]个进行互换
//打印，一个 for循环遍历搞定
//求平均值，定义一个 double ave,一个double sum ；求和取平均
//定义 double max,min;以及int他们对应的下标maxIndex.minIndex，for循环遍历
//定义一个Scanner 对象， 来存储要寻找的数
//定义double search,for循环判断是否相等，相等就break，并输出
//后续改版就是可以键盘输入
//正式实现，随机数
int random = 0;
Scanner scanner =new Scanner(System.in);
System.out.println("你想要生成几个随机数：");
int inputNumber = scanner.nextInt(); //接收数组大小
double[] array = new double[inputNumber];//生成随机数数组
double average = 0;//平均数
double sum = 0;//为求平均数使用
double max = array[0];//最大最小值以及下标
int maxIndex = 0;
for(int i = 0; i < inputNumber; i++){ //在数组中插入元素
random = (int)(Math.random()*100 + 1);
array[i] = random;
}
//查看生成后的数组
System.out.println("生成后的数组为：");
for(int i = 0; i < inputNumber; i++){
System.out.print(array[i]+ " ");//打印生成的原始数组
}
System.out.println();
//倒序打印
for(int i = 0; i < inputNumber / 2; i++){
double temp = array[i];
array[i] = array[inputNumber - i -1];
array[inputNumber - i -1] = temp;
}
System.out.println("倒序后的数组为：");
for(int i = 0; i < inputNumber; i++){
System.out.print(array[i]+ " ");//打印新数组
}
System.out.println();
//求平均数，最大最小值以及下标
double min = array[0];//这两个要在这里定义，要不然根本没有效果
int minIndex = 0;
for(int i = 0; i < inputNumber; i++){
sum += array[i];
if(array[i] > max){
max = array[i];
maxIndex = i;
}
else if(array[i] < min){
min = array[i];
minIndex = i;
}
}
average = sum / inputNumber;
System.out.println("求得的平均数为：" + average);
System.out.println("求得的最大值为：\t" + max + "\t 对应的下标为：\t" + maxIndex + "\t是第 \t" + (maxIndex + 1) +"\t个数\t");
System.out.println("求得的最小值为：\t" + min + "\t 对应的下标为：\t" + minIndex + "\t是第 \t" + (minIndex + 1) +"\t个数\t");
//找数
System.out.println("输入你想要寻找的数：");
double find = scanner.nextDouble();
int findIndex = -1;
for(int i = 0; i < inputNumber; i++){
if(array[i] == find){
findIndex = i;
break;
}
}
if(findIndex != -1){
System.out.println("你输入的数字\t" + find + "\t已经找到 对应的下标为：\t" + findIndex + "\t是第 \t" + (findIndex + 1) +"\t个数\t");
}else{
System.out.println("你输入的数字\t" + find + "\t 没有找到 ");
}
//你想要生成几个随机数：
//5
//生成后的数组为：
//73.0 28.0 87.0 67.0 21.0
//倒序后的数组为：
//21.0 67.0 87.0 28.0 73.0
//求得的平均数为：55.2
//求得的最大值为： 87.0 对应的下标为： 2 是第 3 个数
//求得的最小值为： 21.0 对应的下标为： 0 是第 1 个数
//输入你想要寻找的数：
//67
//你输入的数字 67.0 已经找到 对应的下标为： 1 是第 2 个数
6、试写出以下代码的输出结果
char[] arr1 = {'a','b','陈','d'};
char[] arr2 = arr1;
for(int i = 0; i < arr1.length; i++){
System.out.println(arr1[i] + " ," + arr2[i]);
}
//输出的是
//a,a
//b,b
//陈,陈
//d,d
//这个就是地址问题，arr1 和 arr2 指向的是同一个地址空间，只要这个地址里面的数一改，两个数组内容都会改变
扫一扫
2799
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
