数组（二）
三 、可变长参数
-
作用：JDK5.0 特性多个相同类型数据作为参数时可自动封装为数组，一定程度上替换数组类型参数
-
语法：在参数表中使用， 数据类型... 参数名 定义参数
int[] a = {1,2,3,4,5}; m1(a); m1(10,20,30);//自动封装为数组 m1(); public static void m1(int... a){ //在m1函数中 使用a 等同于使用数组 for(int i=0; i<a.length; i++){ System.out.println(a[i]); } }注意：
- 一个方法只允许有一个可变长参数，反例：m1(int... a, int... b)
- 可变长参数必须为方法的最后一个参数，反例：m1(int... b,int c)
四、数组排序
(一) 元素反转
- 将元素组元素颠倒
![]
(https://img2022.cnblogs.com/blog/2668600/202209/2668600-20220927210801472-1190285328.png) - 代码实现：
int[] as = {100,80,70,60,40};
int n = as.length;
//翻转次数为数组长度/2
//i=0 as[0] ←→ as[4]
//i=1 as[1] ←→ as[3]
// as[i] ←→ as[a.length-i-1]
for (int i = 0; i < n/2; i++) {
//交换元素位置
int temp = as[i];
as[i] = as[n-i-1];
as[n-i-1] = temp;
}
//Arrays.toString( 数组引用 )：可以将数组转换为字符串
System.out.println(Arrays.toString(as));
(二).交换两个变量的值
场景：如何交换两个变量的值?
解决办法1：借助第三方变量，比如交换两个杯子中的水，如下图 (常用)
案例代码
int a=10,b=20,c;
c=a; //将变量a的值赋值给c
a=b; //将变量b的值赋值给a
b=c; //将变量c的值赋值给b
注意：注意变量交换的顺序
(三).冒泡排序
排序规则：数组两个相邻的元素依次比较，每次将最大的数值放到最后的位置
效果如下：
还看不懂？
再看看这个更加详细的
一组数据：8,9,6,5,7,3
// 0 1 2 3 4 5 下标 数组长度 n = 6;
// 8 9 6 5 7 3 数组成员
// 第一轮
//0-1 8 9 6 5 7 3 i=0
//1-2 8 6 9 5 7 3 int j=0;j<5;j++
//2-3 8 6 5 9 7 3 i和j之间有一种莫名其妙的关系比如，j的上限 = 5-i;
//3-4 8 6 5 7 9 3
//4-5 8 6 5 7 3 9
// 第二轮
//0-1 6 8 5 7 3 9 i=1
//1-2 6 5 8 7 3 9 int j=0;j<4;j++
//2-3 6 5 7 8 3 9 j的上限 = 5-i;
//3-4 6 5 7 3 8 9
// 第三轮
//0-1 5 6 7 3 8 9 i=2
//1-2 5 6 7 3 8 9 int j=0;j<3;j++
//2-3 5 6 3 7 8 9 j的上限 = 5-i;
// 第四轮
//0-1 5 6 3 7 8 9 i=3
//1-2 5 3 6 7 8 9 int j=0;j<2;j++ j的上限 = 5-i;
// 第五轮
//0-1 3 5 6 7 8 9 i=4 int j = 0;j<1;j++ j的上限 = 5-i;
//注意：5从哪里来的？ 你猜？ 没错就是 数组长度-1 即 array.length-1
for(int i=0;i<array.length-1;i++){ //i 控制的循环总轮数，
for(int j=0;j<array.length-1-i;j++){ // j 数组每轮的循环次数 注意i和j之间的关系？
if(array[j]>array[j+1]){
int k = array[j];
array[j] = array[j+1];
array[j+1] = k;
}
}
}
(四).选择排序
排序规则：每一次从无序区元素中选出最小的一个元素，存放在无序区的起始位置，直到全部待排序的元素排完。
效果如下
好了，我们一起来推理一下
int[] array = {8,9,6,5,7,3};
// 0 1 2 3 4 5 数组长度 n = 6;
// 8 9 6 5 7 3
// 第一轮 外层循环的轮数 为 数组长度-1
// 0-1 8 9 6 5 7 3 i=0
// 0-2 6 9 8 5 7 3 j = 1;j<6;j++
// 0-3 5 9 8 6 7 3
// 0-4 5 9 8 6 7 3
// 0-5 3 9 8 6 7 5
// 第二轮
// 1-2 3 8 9 6 7 5 i=1
// 1-3 3 6 9 8 7 5 j=2;j<6;j++
// 1-4 3 6 9 8 7 5
// 1-5 3 5 9 8 7 6
// 第三轮
// 2-3 3 5 8 9 7 6 i=2
// 2-4 3 5 7 9 8 6 j=3;j<6;j++
// 2-5 3 5 6 9 8 7
// 第四轮
// 3-4 3 5 6 8 9 7 i=3
// 3-5 3 5 6 7 9 8 j=4;j<6;j++
// 第五轮
// 4-5 3 5 6 7 8 9 i=4
// j=5;j<6;j++
// 外层循环的写法如下
for(int i=0;i<array.length-1;i++){
for(int j=i+1;j<array.length;j++){
//比较的元素是谁呢？ array[i] 和array[j]
if(array[i]>array[j]){
int c = array[i];
array[i] = array[j];
array[j] = c;
}
}
}
//遍历排序后的数组
for(int i= 0;i<array.length;i++){
System.out.println(array[i]);
}
(五) JDK提供的快速排序
-
方法： java.util.Arrays.sort();
-
特点：由JDK实现的快速排序
-
使用方法：
int[] a = {19,8,6,1,4}; java.util.Arrays.sort( a );//排序完成 //打印输出 System.out.println( java.util.Arrays.toString( a ) );//1 4 6 8 19
五、二维数组
- 例：
一个一维数组可以表示 学生的各个学科成绩
保存多名学生的成绩就需要多个一维数组
将多个一位数组存储到另一个数组中就组成了二维数组
数组中的每个元素又是一个数组（二维表结构）
(一) 二维数组的创建
1.基本语法
数据类型 [][] 数组名 = new 数据类型[高维长度][低维长度];
高纬长度决定外部一维数组的长度（行数）
低维长度决定内部每个一维数组的长度（列数）
例：
int[][] a = new int[3][5];//该数组由3行5列构成
2.显示初始化
例：创建一个三行三列二维数组
数据类型[][] 数组名;
数组名 = new 数据类型[][] {
{一行一列值,一行二列值...},
{二行一列值,二行二列值...},
{三行一列值,三行二列值...}
};
语法：
int[][] a;
a = new int[][] {
{10,20,30},
{40,50,60},
{70,80,90}
};
3.显示初始化[简写形式]
语法：
数据类型[][] 数组名 = {
{一行一列值,一行二列值...},
{二行一列值,二行二列值...},
{三行一列值,三行二列值...}
};
例：
int[][] a = {
{10,20,30},
{40,50,60},
{70,80,90}
};
注意: 简写形式必须保证声明与初始化必须同时进行，不能先声明再初始化。
（二）二维数组下标与长度
- 二维数组下标 二维数组其实本质是一维数组中的一维数组，外层数组中的每个元素又是一个数组 例：
//创建二维数组a
int[][] a = new int[3][5];
//a本身是一个数组,所以可以通过下标直接操作
a[0]
a[1]
a[2]
//但是由于a[0]、a[1]、a[2]也都是数组，所以要访问内部的元素需要说明是哪个一维数组中的元素
//固然就会出现以下的语法
a[0][1]//访问a[0]数组下标为1的元素
a[2][0]//访问a[2]数组下标为0的元素...
二维数组的下标由两部分构成，分为高维（行、外层数组下标）与低维（列，内层数组下标）。
-
二维数组内存结构
![]()
-
使用双下标操作数组 例：
//该数组由3行5列构成
int[][] a = new int[3][5];
a[0][0] = 10;//向a[0]数组下标为0的位置添加元素
a[0][2] = 50;//向a[0]数组下标为2的位置添加元素
a[1][0] = 100;//向a[1]数组下标为0的位置添加元素
a[1][1] = 70;//向a[1]数组下标为1的位置添加元素
a[2][0] = 150;//向a[2]数组下标为0的位置添加元素
System.out.println(a[0][0]);//打印a[0]数组下标为0的元素
System.out.println(a[0][2]);//打印a[0]数组下标为2的元素
System.out.println(a[1][0]);//打印a[1]数组下标为0的元素
System.out.println(a[1][1]);//打印a[1]数组下标为1的元素
....略
- 获取二维数组长度 获取高维数组长度
数组名.length
获取低维数组长度
数组名[高维下标].length
例：
int[][] a = new int[3][5];
System.out.println( a.length );//打印a数组（高维）数组长度
System.out.println( a[0].length );//打印a[0]（低维）数组长度
System.out.println( a[1].length );//打印a[1]（低维）数组长度
（三）遍历二维数组
- 思路：先遍历高维数组获取一维数组，再遍历一维数组获取元素 例：
int[][] a = new int[3][5];
for(int i=0; i<a.length; i++){//遍历高维数组
int[] ax = a[i];//获取低维数组
for(int j=0; j<ax.length; j++){//遍历低维数组获取元素
System.out.print( ax[j] +"\t");//打印不换行，让一维数组所有元素展示在一行
}
System.out.println();//打印换行
}
输出结果：
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
简化版：
int[][] a = new int[3][5];
for(int i=0; i<a.length; i++){//遍历高维数组
for(int j=0; j<a[i].length; j++){//遍历a[i]低维数组获取元素
System.out.print( a[i][j] +"\t");//打印不换行，让一维数组所有元素展示在一行
}
System.out.println();//打印换行
}
（四）不规则二维数组
- 特点：创建时只指定高维数组长度，每个低维数组的长度不再固定，需要手动初始化每个低维数组 语法：
//创建高维数组
数据类型[][] 数组名 = new 数据类型[高维长度][];
//单独分配每个低维数组
数组名[0] = new 数据类型[低维长度];
数组名[1] = new 数据类型[低维长度];
数组名[2] = new 数据类型[低维长度];
...
例：
int[][] a = new int[3][];//指定高维长度（行数）
a[0] = new int[2];//手动初始化低维数组（每行列数）
a[1] = new int[5];
a[2] = new int[3];
内存结构：
浙公网安备 33010602011771号