Java奠基】数组的讲解与使用

数组概述

数组是一种容器，可以用来存储同种数据类型的多个值，数组容器在存储数据的时候，需要结合隐式转换考虑。例如：int类型的数组容器不能存放取值范围比它大的boolena和double，double类型的数组取值范围最大，可以存放所有类型的数组。注意：容器的类型，和存储的数据类型保持一致

数组的定义与初始化

在Java中定义数组有两种方式，如下：

格式一：数据类型 [ ] 数组名

int [ ] array

格式二：数据类型数组名 [ ]

int array[ ]

数组的初始化就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程，数组初始化有两种方式，如下：

数组的静态初始化：其使用方式如下：

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

int [ ] array = new int[ ]{ 11,12,13 };

在开发过程中，我们一般会使用其简写形式，如下：

int [ ] array = { 11,12,13 };

public class Main {
    public static void main(String[] args) {
        // 存储年龄的数组
        int[] arr1 = new int[]{11,12,13};
        int[] arr2 = {14,15,16}; // 简写
        // 存储姓名的数组
        String[] arr3 = new String[]{"张三","李四","王五"};
        String[] arr4 = {"陈六","戴七","赵八"}; // 简写
        // 获取数组的元素值
        System.out.println(arr1[0]); // 11
        System.out.println(arr3[1]); // 李四
        System.out.println(arr4); // [Ljava.lang.String;@4eec7777 [表示地址值，后面数值表示地址值
    }
}

数组的动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。其使用方式如下：

格式：数据类型 [ ] 数据名 = new 数据类型[ 数据长度 ];

范例：int [ ] arr = new int[ 3 ];

public class Main {
    public static void main(String[] args) {
        // 创建动态初始化数组
        int[] arr = new int[10];
        arr[0] = 1;
        arr[1] = 2;
        System.out.println(arr[0]); // 1
        System.out.println(arr[1]); // 2
        System.out.println(arr[2]); // 0
    }
}

注意：在数组动态初始化的时候有以下规律

整数类型：默认初始值为0

小数类型：默认初始值为0.0

字符类型：默认初始值 ‘/u0000’ 空格

布尔类型：默认初始值为false

引用数据类型：默认初始值为null

数组静态初始化与动态初始化的区别：

静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度。

动态初始化：手动指定数组长度，由系统给出默认初始值。

需求中已经明确了要操作的具体数据，直接静态初始化即可；只明确元素个数，不明确具体数值，推荐使用动态初始化。

数值遍历

数组遍历就是将数组中所有的内容取出来，进行相关的数组数据操作，如下：

public class Main {
    public static void main(String[] args) {
        // 存储年龄的数组
        int[] arr = {11,12,13,14,15,16,17,18};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 存储年龄的数组
        int[] arr = {11,12,13,14,15,16,17,18};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println(sum); // 116
    }
}

数组的常见操作

接下来列举Java中操作数据最常见的案例：

求最值

public class Main {
    public static void main(String[] args) {
        // 定义数组并存储5个数值，找出最大值
        int[] arr = {12,14,16,67,85};
        // 临时认为0索引的数据是最大的
        int max = arr[0];
        // 循环遍历数组，将数组中的每个元素与max进行比较
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max){
                max = arr[i];
            }
        }
        // 循环结束，max记录的就是数组的最大元素
        System.out.println(max); // 85
    }
}

求和平均并统计个数

public class Main {
    public static void main(String[] args) {
        // 定义动态初始化数据，求和与平均
        int[] arr = new int[10];
        // 将随机数存入r当中
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            // 将每循环一次的随机数存储到变量number当中
            int number = r.nextInt(100)+1;
            // 将随机数添加到数组当中
            arr[i] = number;
        }
        // 求和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println("数组中的和为："+sum);
        System.out.println("数组中的平均数为："+sum/arr.length); // 求平均
        // 求比数组的平均数小的元素个数
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<sum/arr.length){
                count++;
            }
        }
        System.out.println("比平均数小的元素个数："+count);
    }
}

交换数据

public class Main {
    public static void main(String[] args) {
        // 定义数组存储数据
        int[] arr = {12,14,15,16,18};
        // 利用循环交换数组
        for (int i = 0,j = arr.length-1; i < j; i++,j--) {
            // 交接变量i和变量j指向的数据
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        // 循环结束之后，数组中的数据就实现了头尾交换
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+ " "); // 18 16 15 14 12 
        }
    }
}

打乱数据

public class Main {
    public static void main(String[] args) {
        // 定义数组存储数据
        int[] arr = {12,14,15,16,18};
        Random r = new Random();
        // 循环遍历数组，从0索引开始打乱数据的顺序
        for (int i = 0; i < arr.length; i++) {
            // 生成一个取值范围为数组长度的随机索引
            int randomindex = r.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[randomindex];
            arr[randomindex] = temp;
        }
        // 当循环结束之后，那么数组中的所有数据已经打乱顺序
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

数组内存图

在Java中内存分配主要有以下几种：

栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

堆：存储对象或者数组，new来创建的，都存储在堆内存。

方法区：存储可以运行的class文件。

本地方法栈：JVM在使用操作系统功能的时候使用，和我们开发无关。

寄存器：给CPU使用，和我们开发者无关。

注意：只要是new出来的一定是在堆里面开辟了一个小空间，如果是new了多次，那么在堆里面有多个小空间，每个小空间中都有各自的数据。

当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了。