Java-3-数组

6. JAVA数组

数组：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

数组的特点：

1. 数组是一种引用数据类型

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

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

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

两种常见的初始化方式：

1. 动态初始化（指定长度）

2. 静态初始化（指定内容）

6.1 动态初始化

动态初始化数组的格式：

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

解析含义：

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

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

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

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

6.2 静态初始化

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

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

public class demo01 {
    public static void main(String[] args) {
// =================静态初始化======================
        // 创建一个int数组，具体为: 5, 15, 25
        int[] array2 = new int[]{5, 15, 25};
        // 创建一个String数组，具体为: "Hello", "World", "Java"
        String[] string2 = new String[]{"Hello", "world", "Java"};

        // 使用静态初始化数组时，格式还可以省略一下。
        // 数据类型[] 数组名称 = {元素1, 元素2, 元素3, ...}
        int[] array3 = {5, 15, 20};


        // 注意事项
        // 1. 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
        // 2. 静态初始化标准格式可以拆分成为两个步骤。
        // int[] array;
        // array = new int[]{5, 15, 20};
        // 3. 动态初始化也可以拆分为两个步骤。
        // int[] array;
        // array = new int[3];
    }
}

6.3 数组的赋值使用

package com.tipdm.demo1;

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

        System.out.println(array[0]);  // 0
        System.out.println(array[1]);  // 0
        System.out.println(array[2]);  // 0
        System.out.println("===============");

        // 修改数据
        // 将数据123赋值给array当中的1号元素
        array[1] = 123;
        System.out.println(array[0]);  // 0
        System.out.println(array[1]);  // 123
        System.out.println(array[2]);  // 0
    }
}

6.4 Java的内存划分

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

6.4.1 栈（Stack）

• 存放的都是方法中的局部变量。方法的运行一定要在栈当中。

局部变量：方法的参数，或者是方法{}内部的变量。

作用域：一旦超出作用域，立刻从栈内存当中消失。

6.4.2 堆（Heap）

• 凡是new出来的东西，都在堆当中。

堆内存里面的东西都有一个地址值：16进制

堆内存里面的数据，都有默认值。规则：

• 如果是整数类型，那么默认为0；
• 如果是浮点类型，那么默认为0.0；
• 如果是字符类型，那么默认为‘\u0000’；
• 如果是布尔类型，那么默认为false；
• 如果是引用类型，那么默认为null。

6.4.3 方法区（Method Area）

• 存储.class相关信息，包含方法的信息。

6.4.4 本地方法栈（Native Method Stack）

• 与操作系统相关

6.4.5 寄存器(pc Register)

• 与CPU相关

6.5 数组在内存中工作原理

6.5.1 单个数组

6.5.2 多个数组（不产生交叉）

6.5.3 多个数组（产生交叉）

6.6 案例练习

6.6.1 计算数组中的最大值和最小值

package com.tipdm.demo1;

/**
 * 计算数组中的最大值和最小值
 */

public class demo11 {
    public static void main(String[] args) {
        int[] array = {15, 20, 35, 45, 55, 11, 31, 88, 1000, 31, 0, -55};
        int max = array[0];
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i]){
                max = array[i];
            }
            if (min > array[i]){
                min = array[i];
            }
        }
        System.out.println("Max:" + max);
        System.out.println("Min:" + min);
    }
}

6.6.2 数组元素的反转

package com.tipdm.demo1;

/**
 * 数组元素的反转：
 * 本来的样子{1, 2, 3, 5, 6}
 * 输出的结果{6, 5, 3, 2, 1}
 *
 * 数组的元素反转，其实就是对称位置的元素交换
 */
public class demo12 {
    public static void main(String[] args) {
        int[] array = {15, 20, 3, 2, 5, -1, 0};

        for(int min = 0, max = array.length - 1; min <= max; min++, max--){
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

6.6.3 数组作为参数传入方法

package com.tipdm.demo1;

public class demo13 {
    public static void main(String[] args) {
        int [] array = {10, 20, 30, 40, 50};
        String[] array1 = {"Hello", "World"};
        printArray(array);
        printArray(array1);
    }

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

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

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

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

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

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

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

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

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

6.6.4 数组作为方法返回值返回

package com.tipdm.demo1;

/**
 * 数组作为返回值
 * 一个方法可以有0，1，多个参数；但是只能有0/1个返回值，不能有多个返回值。
 *
 * 案例计算一个int数组的均值和总和。
 */
public class demo14 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int[] result = cal(array);
        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }
    }

    public static int[] cal(int[] x){
        int sum = 0;
        for (int i = 0; i < x.length; i++) {
            sum += x[i];
        }
        int avg = (int) sum/x.length;
        int[] res = {sum, avg};
        return res;
    }
}