Java初体验（5）之数组

一维数组

格式、初始化

● 动态初始化：
数据类型 [ ] 数组名 = new 数据类型 [ 数据长度 ]；
int [ ] arr = new int [5];
先进行默认初始化值，在将地址赋给栈，然后在改变初始化的值

        //动态初始化
        int[] arr = new int[5];//代表可以存储5个int类型，动态初始化
        System.out.println(arr[0]);//0，系统的默认初始化值
        arr[0] = 10;
        arr[1] = 20;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr);//[I@154617c,[代表一位数组，I代表int类型，@ 固定的，后面的代表hashcode的地址值

● 静态初始化：
数据类型 [ ] 数组名 = new 数组类型 [ ] {元素1，元素2…}
数据类型 [ ] 数组名 = {元素1，元素2…}
int [ ] arr = new int [ ]{3,4,1,9,2,5}
int [ ] arr = {3,4,1,9,2,5}
先进行默认初始化值，在进行显示初始化值，再将地址值赋给栈

        //静态初始化
        int[] array1 = new int[]{11,92,13,14,15};
        int[] array2 = new int[]{11,12,13,14,15};
        System.out.println(array[3]);

数组默认初始值
* 整数类型：默认初始化值是0
* 浮点类型：默认初始化值是0.0
* 布尔类型：默认初始化值是false
* 字符类型：char默认初始化值是\u0000
* char在内存中占的两个字节，是16个二进制位，\u0000每个0代表的是16进制的0，
* 那么四个0就是代表16个二进制位，\u(0000)(0000)(0000)(0000)
三个引用两个数组

        //三个引用，两个数组,两引用指向同一个实体
        int[] array1 = new int[3];
        int[] array2 = new int[5];
        int[] array3 = array2;
        System.out.println(array1);
        System.out.println(array2);
        System.out.println(array3);

异常

1. ArrayIndexOutofBoundsException：数组索引越界异常
   *原因：你访问了不存在的索引

        int[] array = new int[]{11,92,13,14,15};
        System.out.println(array[7]);

异常：
2. NullPointerException：空指针异常
*原因：数组已经不再指向堆内存了。却还用数组名去访问元素

        array = null;//将数组引用赋值为null
        System.out.println(array[1]);

异常：

数组的操作

一维数组的遍历：
将遍历抽取成方法

    /*数组的遍历*/
    public static void print(int []array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

将数组以行的形式打印出来：Arrays.toString();

获取最值：

    /*获取数组中的最大值*/
    public static int getMax(int []array) {
        int Max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (Max < array[i]){
                Max = array[i];
            }
        }
        return Max;
    }

反转：

    /*数组的翻转*/
    public static void reverseArray(int[] arr) {
        for (int i = 0; i < arr.length/2 ; i++) {
            int tmp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = tmp;
        }
    }

查找指定元素：

    /*数组元素查找*/
    public static int getIndex(int[] arr,int value) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value){
                return i;
            }
        } return -1;
    }

二维数组

格式

● int [ ] [ ] arr = new int [3] [2];
这是一个二维数组，这个二维数组中有3个一维数组，每个一维数组中有2个元素

● int[ ] [ ] arr = new int [3] [ ];
这是一个二维数组，这个二维数组中有3个一维数组，三个一维数组都没有赋值

注意：数组的默认初始化值是null，属于引用数据类型
● int[ ] [ ] arr = { {1,2,3}, {4,5}, {6,7,8,9} };
这是一个二维数组，这个二维数组中每个大括号都代表一个一维数组

        int[][]arr2 = {{4,5},{1,2,3},{6,7,8,9}};
        System.out.println(arr2); // [[I@14ae5a5 代表二维数组的地址值
        System.out.println(arr2[0]) ;// [I@131245a 代表的是一维数组的地址值
        System.out.println(arr2[0][0]); // 1 代表的是它的值

数组的操作

二维数组的遍历：
采用双重循环
*外循环控制的是二维数组的长度，其实就是一维数组的个数
*内循环控制的是一维数组的长度

 /*遍历二维数组*/
    public static void print(int[][]arr) {
        for (int i = 0; i < arr.length; i++) {//获取到每个二维数组的一维数组
            for (int j = 0; j < arr[i].length; j++) {//获取到每个一维数组的元素
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }

求和

    /*求和*/
    public static int sum(int[][]arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }
        return sum;
    }

值传递问题

● 基本数据类型的值传递，不改变原值，调用会发生弹栈，局部变量会消失（只是在栈中进行调用，调完弹出）
● 应用数据类型的值传递，改变原值，因为即使方法弹栈，但是堆内存数组对象还存在，还可以通过地址进行访问