Java学习 第三章 数组（二）多维数组

多维数组的使用

由数组构成的数组

二维数组：
① 二维数组的声明和初始化
② 如何调用数组的指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组
⑤ 数组元素的默认初始化值 ：见ArrayTest1.java
数组元素是整形：0
数组元素是浮点型：0.0
数组元素是char型：0或‘\u0000’
数组元素是布尔型：false
数组元素是引用数据类型时：null
⑥ 数组的内存解析 ：见ArrayTest1.java
① 二维数组的声明

int[] arr = new int[]{1,2,3};  //一维数组
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};;  //一维数组

① 二维数组的初始化1

String[][] arr2 = new String[3][2];
String[][] arr3 = new String[3][];

//正确：

int[] arr4[] = new int [][]{{1,2,3},{4,5},{6,7,8}};
int[] arr4[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

② 如何调用数组的指定位置的元素

System.out.println(arr1[0][1]);;//2
System.out.println(arr3[1][1]; //null

③ 如何获取数组的长度

System.out.println(arr4.length);//3
System.out.println(arr4[0].length);//3

④ 如何遍历二维数组

for(int i = 0;i<arr4[i].length;i++){
    for(int j = 0;j < arr[i].length;j++){
        System.out.print(arr4[i][j] + "  ");
    }
}

二维数组遍历需要两层for循环

⑤ 数组元素的默认初始化值 ：见ArrayTest1.java
数组元素是整形：0
数组元素是浮点型：0.0
数组元素是char型：0或‘\u0000’
数组元素是布尔型：false
数组元素是引用数据类型时：null
⑥ 数组的内存解析 ：见ArrayTest1.java
规定：二维数组分为外层数组的元素，内层数组的元素

int[][] arr = new int[4][3];

外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等；

int[][] arr = new int[4][3];
System.out.println(arr[0]);//输出地址值
System.out.println(arr);//输出二维数组首地址

针对初始化方式一、比如：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组的初始化情况相同。
针对初始化方式二、比如：int[][] arr = new int[4][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。
⑥ 二维数组的内存解析 ：

数组长度一旦确定，就不可修改.

数据结构：
1.数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
2.数据的存储结构：
线性表：顺序表（比如：数组）、链表、栈、队列
树形结构：二叉树
图形结构

算法：
排序算法：
搜索算法：

二维数组课后练习题：
获取arr数组中所有元素的和。：使用for嵌套循环即可。

int [][] arr = new int[][]{{3,5,8},{12,9},{7,0,6,4}};

int sum = 0; //记录总和
for(int i = 0 ； i<arr.length;i++){
for(int j = 0;j<arr[i].length;j++){
sum+=arr[i][j];
}
}
System.out.println("总和为： " +sum);

杨辉三角：

package shangguigu;
public class array {
    public static void main(String[] args){
       //1.声明并初始化二维数组
       int[][] yanghui = new int[10][];
       //2.给数组的元素赋值
       for(int i = 0;i<yanghui.length;i++) {
             yanghui[i] = new int[i+1];
             //2.1给首末元素赋值
             yanghui[i][0] = yanghui[i][i] = 1;
             //2.2给非首末元素赋值
             if(i>1) {
                    for(int j = 1;j<yanghui[i].length-1;j++) {
                           yanghui[i][j] = yanghui[i-1][j-1]+yanghui[i-1][j];
                    }
             }
       }
       //3.遍历二维数组
       for(int i = 0;i<yanghui.length;i++) {
             for(int j = 0;j<yanghui[i].length;j++) {
                    System.out.print(yanghui[i][j]+" ");
             }
             System.out.println();
       }
             //3.
             
    }
}

array2 = array1;// 这是把array1的地址赋值给array2，两个指向的是同一个数组，所以当array2改变的时候，array1也会跟着改变。

array2 = new int[array1.length};
for(int i=0; i<array2.length; i++)
{
array2[i] = array1[i];
}

因为此处new了一个新数组，所以是新开辟了一段内存空间，是真的”复制“了array1给array2，修改array2的值不会改变array1.

数组的复制：

String[] arr1 = new String[arr.length];
for(int i = 0;i<arr1.length;i++){
arr1[i] = arr[i];
}

数组的反转：

for(int i =0;i<arr1.length/2;i++){
    String temp = arr[i];
arr[i] = arr[arr.length -i-1] = temp;
}

数组的反转方式2：

for(int i = 0,j = arr.length - 1;i<j;i++,j--){
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

数组的查找：
①线性查找：

String dest = "BB";
for(int i = 0; i<arr.length ; i++){
    if(dest.equals(arr[i])){
System.out.println("找到了指定位置的元素，位置为："+i);
isFlag = false;
break;
}
}
if(isFlag){
System.out.println("很遗憾，没有找到哦！")；
}

②二分法查找：
//前提：所要查找的数组必须有序

//3.二分法查找

   int[] arr2 = new int[] {-98,-34,2,34,54,66,79,105,210,333};
   
   int dest = -34;
   int head = 0;//初始索引值
   int end = arr2.length - 1;//初始的末索引
   boolean isFlag = true;
   
   while(head<=end) {
         int middle = (head+end)/2;
         if(dest == arr2[middle]) {
                System.out.println("找到了指定位置的元素，位置为： "+middle);
                isFlag = False;break;
         }else if(arr2[middle]>dest) {
                end = middle-1;
         }else {
                head = middle + 1;
         }
   }
   if(isFlag) {
         System.out.println("很遗憾，没有找到！");
   }