-
什么是多维数组
多维数组和一维数组原理是一样的 -
声明一个二维数组
int[][] arr;
- 两个
[ ]标识二维数组 - int[] [] 二维数组：存放的是一维数组，一维数组中存放的是int类型的数据
- arr 名字
- 为二维数组初始化并赋值
- 静态初始化：
arr = new int[][]{ {1,2,3}, {4,5,6}, {7,8} }; - 动态初始化：
方式一：二维数组中的每一个一维数组长度都一致
//{ {0,0,55,0,0,0},{0,0,0,0,0,0},{0,6,0,0,0,0},{0,0,0,0,0,0}{0,0,0,0,0,0} }
arr = new int[5][6];
arr[0][2] = 55;
arr[2][1] = 6;
方式二：二维数组中的每一个一维数组长度都不一致
int[][]=arr;
arr=new int[5][];
arr{ {0}, {0,0}, {0,5,0}, {0,0,0,0}, {0,0,0,0,0}}
arr[0] = new int[1];
arr[1] = new int[2];
arr[2] = new int[3];
arr[3] = new int[4];
arr[4] = new int[5];
arr[2][1] = 5;
- 二维数组的长度解读
- arr = new int[5][6];
二维数组长度为5，可以放5个一维数组。
每一个一维数组的长度为6固定存放6个元素 - arr=new int[5][];
arr{ {0}, {0,0}, {0,5,0}, {0,0,0,0}, {0,0,0,0,0}}
二维数组长度为5
然后分开初始化，每一个一维数组的长度根据自定义的长度
- 二维数组的遍历：多重循环
一层取二维数组的一个元素（一维数组）
二层取一维数组的元素
示例
int [][] arr;
arr=new int[2][3];
arr[0][1]=10;
arr[1][2]=20;
1 ）普通for循环遍历
for(int i = 0; i < arr.length; i++){
int[] as = arr[i]; //元素是一维数组，所以声明一维数组类型的变量来接收
for(int j = 0; j < as.length; j++){
int a = as[j]; //元素是int类型变量
System.out.print(a + "\t"); //输出一维数组中的元素
}
System.out.println();
}
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
2 ）增强for循环遍历
for(int[] as : arr){
for(int a : as){
System.out.print(a + "\t");
}
}
- 数组中涉及的常见算法
求：//最大值 //最小值 //总和 //平均值 //数组的复制 //数组的反转 //数组的排序 //数组的遍历
import java.util.Arrays;
class ArrayTest4 {
public static void main(String[] args) {
int[] array = new int[]{5, 19, 0, 14, 66};
//0 array.length - 1 - 0
//1 array.length - 1 - 1
//2 array.length - 1 - 2
//最大值
int max = array[0];
for(int i = 1; i < array.length; i++){
if(array[i] > max){
max = array[i];
}
}
System.out.println("最大值为：" + max);
//最小值
int min = array[0];
for(int i = 1; i < array.length; i++){
if(array[i] < min){
min = array[i];
}
}
System.out.println("最小值为：" + min);
//总和
int sum = 0;
for(int i = 0; i < array.length; i++){
sum += array[i];
}
System.out.println("总和为：" + sum);
//平均值
System.out.println("平均值为：" + (double)sum / array.length);
//数组的复制
int[] array2 = new int[array.length];
for(int i = 0; i < array.length; i++){
array2[i] = array[i];
}
for(int a : array){
System.out.print(a + "\t");
}
System.out.println();
//数组的反转
for(int i = 0; i < array.length / 2; i++){
int temp = array[i];
array[i] = array[array.length - 1 - i];
array[array.length - 1 - i] = temp;
}
//数组的排序
Arrays.sort(array);
//数组的遍历
for(int a : array){
System.out.print(a + "\t");
}
}
}
- 数组的冒泡排序
1 确定一共要比多少轮
2 每一轮比多少次
3 为了提高效率，每一轮比完得出最值，那么这个最值下一轮就不用比了
即：j < x.length-1-i
4 根据什么来比
5 替换的是数组中的元素！
以下代码很早写的,高能预警...
按照电脑的价格比较
实例1：
for(int i=0;i<computer.length-1;i++){//如果长度是5，则i是4，length-1需要比4轮。就会的出一个最大的值
for(int j=0;j<computer.length-1-i;j++){
//j<x.length-1 也可以，每一轮都比4次，但是每一次都得出一个最大值，那么最后的一次比较就多余了
//所以x.length-1-i 每一轮，最后一次的最值都不用再比了
if(computer[j].getPrice()>computer[j+1].getPrice()){
int temp=computer[j].getPrice();//记录第一次开始比较的值
computer[j].setPrice(computer[j+1].getPrice()); //如果j下标元素大于j+1元素，则把j的元素替换成j+1
computer[j+1].setPrice(temp);//但是j+1就没有了，使用标记把j的值给j+1.这样一来，就等于他们的元素位置就换了
}
}
}
//数组排序完成后，遍历结果
for(Computer1 b : computer){
System.out.println(b.getPrice());
}
for(Computer1 c : computer){
System.out.println(c.getDetails());
//发现直接替换掉了对象中价格的属性
}
实例2：
for(int i = 0; i < computers.length - 1; i++){
for(int j = 0; j < computers.length - 1 - i; j++){
if(computers[j].getPrice() < computers[j+1].getPrice()){
Computer com = computers[j];
computers[j] = computers[j+1];
computers[j+1] = com;
//换数组中元素的位置
}
}
}
for(Computer com : computers){
//注意：System.out.println(com.getDetails());
listPrice(com);
}
public static void listPrice(Computer com){//多态参数
System.out.println(com.getPrice());
System.out.println(com.getDetails());//虚拟方法调用
if(com instanceof PC){
PC pc = (PC)com;
pc.hasBox();
}
if(com instanceof NotePad){
NotePad np = (NotePad)com;
np.isFold();
}
}
网友评论