java基础笔记 -- 8.数组&内存

 

一、数组

1.1 数组的概念：

是一种容器，可以同时存放多个数据值。

 

1.2 数组的特点：

* 数组是一种引用数据类型

* 数组当中的多个数据，类型必须统一

* 数组的长度在程序运行期间不可改变

 

1.3 数组的初始化：

在内存当中创建一个数组，并且向其中赋予一些默认值。

 

1.4 两种常见的初始化方式：

1.4.1 动态初始化（指定长度）

在创建数组的时候，直接指定数组当中的数据元素个数。

1.4.2 静态初始化（指定内容）

在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

 

1.5 动态初始化数组的格式

数据类型[] 数组名称 = new 数据类型[数组长度];

例：int[]  array = new int[3];

解析含义:

左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧的中括号[]：代表我是一个数组
左侧数组名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

例1：

public class Demo01Array {

    public static void main(String[] args) {
        // 创建一个数组，里面可以存放300个int数据
        // 格式：数据类型[] 数组名称 = new 数据类型[数组长度];
        int[] arrayA = new int[300];

        // 创建一个数组，能存放10个double类型的数据
        double[] arrayB = new double[10];

        // 创建一个数组，能存放5个字符串
        String[] arrayC = new String[5];
    }

}

/*
静态初始化基本格式：
数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };

注意事项：
虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。
 */
public class Demo02Array {

    public static void main(String[] args) {
        // 直接创建一个数组，里面装的全都是int数字，具体为：5、15、25
        int[] arrayA = new int[] { 5, 15, 25, 40 };

        // 创建一个数组，用来装字符串："Hello"、"World"、"Java"
        String[] arrayB = new String[] { "Hello", "World", "Java" };
    }

}

/*
使用静态初始化数组的时候，格式还可以省略一下。

标准格式：
数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };

省略格式：
数据类型[] 数组名称 = { 元素1, 元素2, ... };

注意事项：
1. 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
2. 静态初始化标准格式可以拆分成为两个步骤。
3. 动态初始化也可以拆分成为两个步骤。
4. 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

使用建议：
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。
 */
public class Demo03Array {

    public static void main(String[] args) {
        // 省略格式的静态初始化
        int[] arrayA = { 10, 20, 30 };

        // 静态初始化的标准格式，可以拆分成为两个步骤
        int[] arrayB;
        arrayB = new int[] { 11, 21, 31 };

        // 动态初始化也可以拆分成为两个步骤
        int[] arrayC;
        arrayC = new int[5];

        // 静态初始化的省略格式，不能拆分成为两个步骤。
//        int[] arrayD;
//        arrayD = { 10, 20, 30 };
    }

}

1.6 数组的访问

1.6.1 索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为 数组索引（index），可以通过数组的索引访问到数组中的元素。

格式： 数组名[索引]   

如：array[2];

1.6.2 数组的长度属性：每个数组都具有长度，而且是固定的，java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length ，属性length的执行数组的长度，int类型结果。由次可以推断出，数组的最大索引值为 数组名.length-1;

public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        // 打印数组的属性，输出结果是5
        System.out.println(arr.length); // 5
    }

1.6.3 索引访问数组中的元素

* 数组名[索引] = 数值，为数组中的元素赋值

* 变量 = 数组名[索引],获取出数组中的元素

public static void main(String[] args) {
        // 定义存储int类型数组，赋值元素1, 2, 3, 4, 5
        int[] arr = {1, 2, 3, 4, 5};
        // 为0索引元素赋值为6
        arr[0] = 6;
        // 获取数组0索引上的元素
        int i = arr[0];
        System.out.println(i); // 6
        // 直接输出数组0索引元素
        System.out.println(arr[0]); // 6
    }

二、数组原理内存

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

1.1 Java虚拟机的内存划分

1.2 数组在内存中的存储

1.2.1一个数组内存图

public class Demo01ArrayOne {

    /*
    1.main方法进入方法栈执行
    2.创建数组，jvm会在堆内存中开辟空间，存储数组
    3.数组在内存中会有自己的内存地址，以十六进制数表示
    4.数组中有3个元素，默认值0
    5.jvm将数组的内存地址赋值给引用类型变量array
    6.变量array保存的是数组内存中的地址，而不是一个具体的数值，因此称为引用数据类型
    */
    public static void main(String[] args) {
        int[] array = new int[3]; // 动态初始化
        System.out.println(array); // [I@140e19d地址值
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 0
        System.out.println(array[2]); // 0
        System.out.println("==============");

        // 改变数组当中元素的内容
        array[1] = 10;
        array[2] = 20;
        System.out.println(array); // 地址值
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 10
        System.out.println(array[2]); // 20
    }

}

以上方法执行，输出的结果是[I@140e19d，这个是什么呢？是数组在内存中的地址。new出来的内容，都是在堆
内存中存储的，而方法中的变量array保存的是数组的地址。
输出arr[0]，就会输出arr保存的内存地址中数组中0索引上的元素

1.2.2 两个数组内存图

public static void main(String[] args) {
        int[] arrayA = new int[3];
        System.out.println(arrayA); // 地址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]); // 0
        System.out.println(arrayA[2]); // 0
        System.out.println("==============");

        arrayA[1] = 10;
        arrayA[2] = 20;
        System.out.println(arrayA); // 地址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]); // 10
        System.out.println(arrayA[2]); // 20
        System.out.println("==============");

        int[] arrayB = new int[3];
        System.out.println(arrayB); // 地址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 0
        System.out.println(arrayB[2]); // 0
        System.out.println("==============");

        arrayB[1] = 100;
        arrayB[2] = 200;
        System.out.println(arrayB); // 地址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 100
        System.out.println(arrayB[2]); // 200
    }

1.2.3 两个变量指向一个数组

public static void main(String[] args) {
        int[] arrayA = new int[3];
        System.out.println(arrayA); // 地址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]); // 0
        System.out.println(arrayA[2]); // 0
        System.out.println("==============");

        arrayA[1] = 10;
        arrayA[2] = 20;
        System.out.println(arrayA); // 地址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]); // 10
        System.out.println(arrayA[2]); // 20
        System.out.println("==============");

        // 将arrayA数组的地址值，赋值给arrayB数组
        int[] arrayB = arrayA;
        System.out.println(arrayB); // 地址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 10
        System.out.println(arrayB[2]); // 20
        System.out.println("==============");

        arrayB[1] = 100;
        arrayB[2] = 200;
        System.out.println(arrayB); // 地址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 100
        System.out.println(arrayB[2]); // 200
    }

三、数组的常见操作

数组的索引编号从0开始，一直到“数组的长度-1”为止。

3.1 数组越界异常

如果访问数组元素的时候，索引编号并不存在，那么将会发生
数组索引越界异常
ArrayIndexOutOfBoundsException

/*
原因：索引编号写错了。
解决：修改成为存在的正确索引编号。
 */
        public class Demo01ArrayIndex {

            public static void main(String[] args) {
                int[] array = { 15, 25, 35 };

                System.out.println(array[0]); //15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 35

        // 错误写法
        // 并不存在3号元素，所以发生异常
        System.out.println(array[3]);
    }

}

3.2 数组空指针异常

观察一下代码，运行后会出现什么结果

public static void main(String[] args) {
    int[] arr = {1,2,3};
    arr = null;
    System.out.println(arr[0]);
}

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候
会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修
改我们编写的代码。

 空指针异常在内存图中的表现

 3.3 数组遍历【重点】

* 数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    System.out.println(arr[3]);
    System.out.println(arr[4]);
}

以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改
造成循环的写法。数组的索引是 0 到 lenght -1 ，可以作为循环的条件出现。

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < arr.length; i++) {
      System.out.println(arr[i]);
    }
}

3.4 数组获取最大值元素

最大值获取：从数组的所有找出最大值

实现思路：
* 定义变量，保存数组 0索引上的元素
* 遍历数组，获取出数组中的每个元素
* 将遍历到的元素和保存数组 0索引上值的变量进行比较
* 如果数组元素的值大于了变量的值，变量记录住新的值
* 数组循环遍历结束，变量保存的就是数组中的最大值

public static void main(String[] args) {
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
    //定义变量，保存数组中0索引的元素
    int max = arr[0];
    //遍历数组，取出每个元素
    for (int i = 0; i < arr.length; i++) {
      //遍历到的元素和变量max比较
      //如果数组元素大于max
      if (arr[i] > max) {
        //max记录住大值
        max = arr[i];
      }
    }
    System.out.println("数组最大值是： " + max);
}

四、数组作为方法参数和返回值

4.1 数组作为方法参数

数组作为方法参数传递，传递的参数是数组内存的地址。

public static void main(String[] args) {
    int[] arr = { 1, 3, 5, 7, 9 };
    //调用方法，传递数组
    printArray(arr);
}
/*
创建方法，方法接收数组类型的参数    
进行数组的遍历    
*/
public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
      System.out.println(arr[i]);
    }
}

4.2 数组作为方法返回值

public static void main(String[] args) {
        // 调用方法，接收的返回值
        // 接收到的是数组的内存地址
        int[] arr = getArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    /*
        创建方法，返回值是数组类型
        return 返回数组的地址
         */
    public static int[] getArray() {
        int[] arr = {1, 3, 5, 7, 9};
        // 返回数组的地址，返回到调用者
        return arr;
    }