第三章 Java语言之数组

第三章 数组

1. 写出一维数组初始化的两种方式

int[] arr = new int[5];//动态初始化
String[] arr1 = new String[]{"a","b","c"};//静态初始化

数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改。

2.写出二维数组初始化的两种方式

静态初始化：
    int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
动态初始化1：
    String[][] arr2 = new String[3][2];
动态初始化2：
    String[][] arr3 = new String[3][];

int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};   

3.如何遍历如下的二维数组

int[] arr = new int[][]{{1,2,3},{4,5},{6,7,8}};

for(int i = 0;i < arr.lenght; i++){
    for(int j =0;j<arr[i].lenght;j++){
        System.out.print(arr[i][j] + "\t");
    }
    System.out.println();
}

4.不同类型的一维数组元素的默认初始化值各是多少

整数：0
浮点数：0.0
char：0
boolean：false
引用类型：null

5. 一维数组的内存解析：

String[] strs = new String[5];
strs[2] = “Tom”;
strs = new String[3];  //重新开辟了地址

6.杨辉三角

public class YangHuiTest {

    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();
        }



    }

7.使用冒泡排序，实现如下的数组从小到大排序。

int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};

for(int i = 0; i< arr.lenght - 1 ;j++){
    for(int j = 0;j < arr.lenght - 1-i; j++){
        if(arr[j] > arr[j+1]){
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

8.数组反转

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

9.复制上述数组，得到一个新的数组

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

10.使用线性查找，从上述数组中查找22是否存在。存在，返回所在位置的索引。不存在，输出提示信息。

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

11.二分查找

 //二分法查找：(熟悉)
        //前提：所要查找的数组必须有序。
        int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int dest1 = -34;
        int head = 0;  //初始的首索引
        int end = arr2.length - 1;//初始的末索引
        boolean flag = true;
        while (head <= end){
            int middle = (head + end)/2;
            if(dest1 == arr2[middle]){
                System.out.println("找到了指定的元素，位置为：" + middle);
                flag = false;
                break;
            }
            else if(arr2[middle] > dest1){
                end = middle - 1;
            }else{
                head = middle+1;
            }
        }
        if(flag){
            System.out.println("很遗憾，没有找到的啦！");
        }

12.数组中常见的异常有哪些？请举例说明

1.ArrayIndexOutOfBoundsException:数组角标越界异常：
合理范围：[0,arr.length -1]
越界：arr[-1],arr[arr.length]
    
2.NullPointerException:空指针异常
int[] arr = null;
arr[0];