JAVA part 4：数组和其内存分配

JAVA part 4：数组和其内存分配

数组

存储同一种数据类型的多个元素的容器

定义格式：
1.数组类型[ ]数组名;
int[ ] arr; 定义了一个int类型的数组，数组名是arr（推荐）
2.数组类型 数组名[];
int arr[ ]; 定义了一个int类型的变量，变量名是arr数组（不推荐）

数组的初始化：

所谓初始化，其实就是为数组开辟内存空间，并为数组中的每个元素赋予初始值

初始化的方法：
1.动态初始化：只给出长度，由系统给出初始化值
2.静态初始化：给出初始化值，由系统决定长度

动态初始化：
数据类型[ ] 数组名 = new 数据类型[数组长度]；

int[] arr = new int[3];
/*
左边：
    int：说明的是数组中的元素类型是int类型
    []：说明这是一个数组
    arr：这是数组的名称
右边：
    new：为数组申请分配内存空间
    int：说明的是数组中的元素类型是int类型
    []：说明这是一个数组
    3：数组长度，其实就是数组中的元素个数
*/

tips：
1.通过输出数组名，可以得到一个地址值
2.如何获取元素值
数组中的 每个元素是有编号的，编号从0开始，最大的编号是数组的长度-1，通过数组名和编号的配合就可以获取数组中指定编号的元素值。（编号的专业叫法是：索引）
获取元素的格式：数组名[索引]

静态初始化：
数据类型[ ] 数组名 = new 数据类型[ ]{元素1, 元素2, 元素3,…}

// 格式一：
int[] arr = new int[]{1, 2, 3};
// 格式二：
int[] arr = {1, 2, 3};

遍历数组

遍历数组可使用for循环

// 需求：数组遍历
package cases;
public class x16 {
    public static void main(String[] args) {

        // 定义一个数组
        int[] arr = {11, 22, 33, 44, 55};

        // 用for循环获取数据0-4
        for(int x=0; x<5; x++) {
            System.out.println(arr[x]);
        }
    }
}

但如果不知道数组中有多少个元素，则可以使用length属性：

使用格式：数组名.length

// 需求：数组遍历
package cases;
public class x16 {
    public static void main(String[] args) {

        // 定义一个数组
        int[] arr = {11, 22, 33, 44, 55};
        
        // 为了解决不知道数组中有多少元素，数组提供了一个属性length用于获取数组中元素的个数
        for(int a=0; a<arr.length; a++){
            System.out.println(arr[a]);
        }
    }
}

获取数组最值

获取最大值/最小值的思路：
1.拿数组中的第一个元素作为参照物
2.遍历数组，从第二个元素开始，一次和参照物进行比较，如果元素比参照物大/小，则留下来做参照物
3.整个比较完毕后，参照物就是最大/最小的值

// 获取最大值
package cases;
public class x17 {
    public static void main(String[] args) {

        // 定义一个数组
        int[] arr = {12, 48, 98, 73, 60};

        // 定义一个参照物
        int max = arr[0];

        // 从第二个元素开始遍历
        for(int x=1; x<arr.length; x++){
            if(arr[x]>max){
                // 如果元素比max大，那么就留下了来继续做参照物
                max = arr[x];
            }
        }
        System.out.println("max:"+max);
    }
}

数组的常见问题

1.数组索引越界异常：

package Day_4;
public class test6 {
    public static void main(String[] args) {

        // 定义一个数组
        int[] arr = new int[3];
        
        // 访问数组中的元素
        System.out.println("arr[3]"+arr[3]);
        
    }
}

上述代码访问了一个数组中不存在的元素，执行后报错：
Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3

2.常量null,它是可以赋值给引用数据类型的，表示该应用不再指向堆内存的数据

package Day_4;
public class test6 {
    public static void main(String[] args) {

        // 定义一个数组
        int[] arr = new int[3];
        //将null赋值给arr
        arr = null;
        //访问数组arr
        System.out.println(arr[1]);
        
    }
}

上述代码访问了一个已经不再指向堆内存的元素，执行就会报错：
Exception in thread “main” java.lang.NullPointerException

JAVA中的内存分配

内存分配

一个数组的内存图

package Day_4;
public class test2 {
    public static void main(String[] args) {
        // 定义一个数组arr
        int[] arr = new int[3];
        
        //输出数组名及元素
        System.out.println("arr:"+arr);
        System.out.println("arr[0]:"+arr[0]);
        System.out.println("arr[1]:"+arr[1]);
        System.out.println("arr[2]:"+arr[2]);
        System.out.println("---------------------");
        
        //给元素赋值
        arr[0] = 100;
        arr[2] = 200;

        //再次输出数组名及元素
        System.out.println("arr:"+arr);
        System.out.println("arr[0]:"+arr[0]);
        System.out.println("arr[1]:"+arr[1]);
        System.out.println("arr[2]:"+arr[2]);
    }
}

两个数组的内存图

package Day_4;
public class test3 {
    public static void main(String[] args) {
        // 定义两个数组arr
        int[] arr1 = new int[2];
        int[] arr2 = new int[3];

        //输出数组名及元素
        System.out.println("arr1:"+arr1);
        System.out.println("arr1[0]:"+arr1[0]);
        System.out.println("arr1[1]:"+arr1[1]);
        System.out.println("---------------------");

        System.out.println("arr2:"+arr2);
        System.out.println("arr2[0]:"+arr2[0]);
        System.out.println("arr2[1]:"+arr2[1]);
        System.out.println("arr2[2]:"+arr2[2]);
        System.out.println("---------------------");

        //给元素赋值
        arr1[0] = 100;

        arr2[0] = 200;
        arr2[2] = 300;

        //再次输出数组名及元素
        System.out.println("arr1:"+arr1);
        System.out.println("arr1[0]:"+arr1[0]);
        System.out.println("arr1[1]:"+arr1[1]);
        System.out.println("---------------------");

        System.out.println("arr2:"+arr2);
        System.out.println("arr2[0]:"+arr2[0]);
        System.out.println("arr2[1]:"+arr2[1]);
        System.out.println("arr2[2]:"+arr2[2]);
    }
}

两个数组指向同一个堆内存

int[ ] arr1 = arr1;
int[ ] arr2 = arr1;

package Day_4;
public class test4 {
    public static void main(String[] args) {
        // 定义两个数组arr
        int[] arr1 = new int[3];

        //给元素赋值
        arr1[0] = 100;
        arr1[1] = 200;
        arr1[2] = 300;

        //输出数组名及元素
        System.out.println("arr1:"+arr1);
        System.out.println("arr1[0]:"+arr1[0]);
        System.out.println("arr1[1]:"+arr1[1]);
        System.out.println("arr1[2]:"+arr1[2]);
        System.out.println("---------------------");

        //定义第二个数组，并使第二个数组的堆内存指向第一个数组
        int[] arr2 = arr1;

        //给元素赋值
        arr2[0] = 111;
        arr2[1] = 222;
        arr2[2] = 333;

        //再次输出数组名及元素
        System.out.println("arr1:"+arr1);
        System.out.println("arr1[0]:"+arr1[0]);
        System.out.println("arr1[1]:"+arr1[1]);
        System.out.println("arr1[2]:"+arr1[2]);
        System.out.println("---------------------");

        System.out.println("arr2:"+arr2);
        System.out.println("arr2[0]:"+arr2[0]);
        System.out.println("arr2[1]:"+arr2[1]);
        System.out.println("arr2[2]:"+arr2[2]);
    }
}