Java小农养成记第四天

Day04

第八章 数组

8.1 数组定义

/*
* 数组：是一种容器，可以同时存放多个数据值
*
* 数组的特点：
* 1.数组是一种引用数据类型
* 2.数组当中的多个数据，类型必须统一
* 3.数组的长度在程序运行期间不可改变
*
* 数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值
*
* 两种常见的初始化方式：
* 1.动态初始化（指定长度）
* 2.静态初始化（指定内容）
*
* 动态初始化数组的格式
* 数据类型[] 数组名称 = new 数据类型[数组长度];
* 数据类型 数组名称[] = new 数据类型[数组长度];
*
* 解析含义:
* 左侧数据类型:也就是数组当中保存的数据，全都是统一的什么类型
* 左侧的中括号:代表我是一个数组
* 左侧数组名称:给数组取一个名字
* 右侧的new:代表创建数组的动作
* 右侧数据类型:必须和左边的数据类型保持一致
* 右侧中括号的长度，也就是数组当中，到底可以保存多少个数据，是一个int数字

* */
public class Demo01Array {

    public static void main(String[] args) {
        int[] arrayA = new int[300];

        double[] arrayB = new double[300];

        String[] arrayC = new String[300];
    }
}

/*
* 动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。
* 静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。
*
* 静态初始化基本格式：
* 数据类型[] 数组名称 = new 数据类型[]  { 元素1, 元素2,……};
* 数据类型 数组名称[] = new 数据类型[]  { 元素1, 元素2,……};
*
* 注意事项：
* 虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。
* */
public class Demo02Array {
    public static void main(String[] args) {
        int[] arrayA = new int[] {5, 15, 25};

        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};
        */
    }
}

/*
* 使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下:
* 如果是整数类型，那么默认为0;
* 如果是浮点类型，那么默认为0.0;
* 如果是字符类型，那么默认为'\u0000';
* 如果是布尔类型，那么默认为false;
* 如果是引用类型，那么默认为nuLl。
*
* 注意事项:
* 静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。
* */
public class Demo05Array {
    public static void main(String[] args) {
        int[] arrayA = new int[3];

        System.out.println(arrayA);//[I@1c53fd30

        System.out.println(arrayA[0]);//0
        System.out.println(arrayA[1]);//0
        System.out.println(arrayA[2]);//0

        //将数据123赋值交给数组arrayA当中的1号元素

        arrayA[1] = 123;
        System.out.println(arrayA[0]);//0
        System.out.println(arrayA[1]);//123
        System.out.println(arrayA[2]);//0
    }
}

8.2 访问数组

/*
* 直接打印数组名称,得到的是数组对应的:内存地址哈希值。
*
* 二进制:01
* 十进制:0123456789
* 16进制:e123456789abcdef
*
* 访问数组元素的格式:数组名称[索引值]
* 索引值:就是一个int数字，代表数组当中元素的编号。
* 【注意】索引值从e开始，一直到“数组的长度-1”为止。

* */
public class Demo04Array {
    public static void main(String[] args) {
        int[] arrayA = {10, 20, 30};
        System.out.println(arrayA);//[I@1c53fd30

        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);

        int num = arrayA[1];
        System.out.println(num);
    }
}

8.3 Java中的内存划分

Java的内存需要划分成为5个部分:

1. 栈(Stack) :存放的都是方法中的局部变量。方法的运行一定要在栈当中。
   局部变量:方法的参数，或者是方法()内部的变量
   作用域:—旦超出作用域，立刻从栈内存当中消失。
2. 堆(Heap):凡是new出来的东西，都在堆当中。
   堆内存里面的东西都有一个地址值:16进制堆内存里面的数据，都有默认值。

规则:
如果是整数 默认为0
如果是浮点数 默认为0.0
如果是字符 默认为‘\u0000’
如果是布尔 默认为false
如果是引用类型 默认为null

3. 方法区(Method Area):存储.class相关信息，包含方法的信息。
4. 本地方法栈(Native Method Stack) :与操作系统相关。
5. 寄存器(pc Register) : 与CPU相关。

8.4 一个数组的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l7t6yNJ9-1641568109960)(index_files/18813a04-e4ad-48b1-8187-6b7a24edfc10.png)]

8.5 练习数组的反转和数组作为方法的参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0f9fyfb8-1641568109961)(index_files/ab8c4926-55e9-4240-8d0b-31d9fb4a174a.png)]

/*
* 数组元速的反转
* 本来的样子是：{10, 20, 30, 40, 50}
* 之后的样子是：{50, 40, 30, 20, 10}
*
* 要求不能使用新数组，就用原来的唯一一个数组。
* 
* 数组可以作为方法的参数。
* 当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。
*/
public class Demo06ArrayReverse {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};
        int l = array.length - 1;

        printArray(array);//地址值

        System.out.println("====================");

        for (int i = 0; i < l; i ++, l--){
            swap(array, i, l);//地址值
        }

        printArray(array);//地址值

    }

    public static void swap(int[] array, int i, int j){
        int temp;
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

8.6 数组作为方法的返回值

/*
* 一个方法可以有0、1、多个参数，但是只能有0或者1个返回值，不能有多个返回值。
* 如果希望一个方法当中产生了多个结果数据进行返回，怎么办?
* 解决方案:使用一个数组作为返回值类型即可。
*
* 任何数据类型都能作为方法的参数类型，或者返回值类型。
*
* 数组作为方法的参数，传递进去的其实是数组的地址值。
* 数组作为方法的返回值，返回的其实也是数组的地址值。
* */
public class Demo02ArrayReturn {
    public static void main(String[] args) {
        int[] result = calculate(10, 20,30);
        System.out.println("总和：" + result[0]);
        System.out.println("平均值：" + result[1]);
    }
    public static int[] calculate(int a, int b, int c){
        int sum = a + b + c;
        int avg = sum / 3;
        int[] array = {sum, avg};
        return array;
    }
}