Java语法基础——数组

数组的概念

同一种类型数据的集合，其实数组就是一个容器。数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式

格式一：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

例，需求：想定义一个可以存储3个整数的容器。

int[] x = new int[3];

格式二：

元素类型[] 数组名 = new 元素类型[]{元素, 元素, ……};

例，

int[] arr = new int[] {3, 1, 6, 5, 4};

以上数组又可简写成：

int[] arr = {3, 1, 6, 5, 4};

Java中的内存分配

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。共划分了5个不同的区域：

栈内存：用于存储局部变量(只要是在方法中定义的变量都是局部变量)，一旦变量的生命周期结束，该变量就被释放。
堆内存：
1. 数组和对象，通过new建立的实例都存放在堆内存中。
2. 每一个实体都有内存地址值。
3. 堆内存的变量都有默认初始化值。不同类型不一样，int为0，double为0.0，boolean为false，char为’\u0000’(即空格)。
4. 实体不再被使用，会在不确定的时间内被垃圾回收器回收。
方法区：又叫方法和数据共享区。运行时期，class文件进入的地方。
本地方法区：和系统底层的方法相关，JVM调用了系统中的功能。
寄存器：给CPU使用，不多说。

Java中数组的内存结构

这一节举例说明在Java中数组的内存结构。
例一，定义一个数组，然后将其指向null，如下：

int[] arr = new int[3];
arr = null;

对于以上代码，数组在内存中的结构为：
这里写图片描述
例二，试看如下代码，你能不能画出数组在内存中的结构图呢？

int[] arr = new int[3];
int[] xxx = new int[3];
arr[1] = 34;
xxx[0] = 89;
System.out.println(arr[0]);

这里写图片描述
例三，最后看一个示例代码，希望你能画出数组在内存中的结构图。

int[] arr = new int[3];
int[] xxx = new int[3];
arr = xxx;
arr[1] = 34;
xxx[0] = 89;
System.out.println(arr[0]);

这里写图片描述

数组操作常见问题

数组操作有两个常见的小问题：

数组脚标越界异常(ArrayIndexOutOfBoundsException)

int[] arr = new int[3];
System.out.println(arr[3]); // ArrayIndexOutOfBoundsException: 3：操作数组时，访问到了数组中不存在的角标

空指针异常(NullPointerException)

int[] arr = new int[3];
arr = null;
System.out.println(arr[1]); // NullPointerException：空指针异常，当引用没有任何指向，值为null的情况，该引用还在用于操作实体。

数组的常见操作

数组遍历

获取数组中的元素，通常会用到遍历，数组中有一个属性可以直接获取到数组的元素个数：length，使用方式：数组名称.length。下面我会用两个例子来讲解数组是如何遍历的。
例一，观察如下程序，你觉得是不是可以获取到数组中的每一个元素。

int[] arr = {3, 6, 5, 1, 8, 9, 67};

System.out.println("length: "+arr.length);
for (int x = 0; x < arr.length; x++) {
    System.out.println("arr["+x+"]="+arr[x]+";"); 
}

此时，直接输出变量arr：

System.out.println(arr);

会得到诸如[I@139a55的值，分析该值：

[：表示是一个一维数组。
I：表示数组中的元素类型是int。
139a55：用哈希算法算出来的地址值。

例二，定义一个功能，用于打印数组中的元素，元素间用逗号隔开。

public static void printArray(int[] arr) {
    System.out.print("[");
    for (int x = 0; x < arr.length; x++) {
        if(x != arr.length - 1)
            System.out.print(arr[x] + ", ");
        else
            System.out.println(arr[x]+"]");
    }
}

获取数组最值

例，给定一个数组，如{5, 1, 6, 4, 2, 8, 9}，获取数组中的最大值，以及最小值。
获取最大值的原理图(获取最小值同理)：
这里写图片描述
用文字描述即为：

获取最值需要进行比较。每一次比较都会有一个较大的值，因为该值不确定，通过一个变量进行存储。
让数组中的每一个元素都和这个变量中的值进行比较，如果大于了变量中的值，就用该变量记录较大值。
当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

步骤如下：

定义变量，初始化为数组中的任意一个元素即可。
通过循环语句对数组进行遍历。
在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量。

此时，我们需要定义一个功能来完成，以便提高复用性。首先须明确两点：

明确结果：数组中的最大元素，int。

未知内容：一个数组，int[]。

public static int getMax(int[] arr) {
    int max = arr[0];

    for (int x = 1; x < arr.length; x++) {
        if(arr[x] > max) 
            max = arr[x];
    }
    return max;
}

获取最大值的另一种方式，可不可以将临时变量初始化为0呢？可以，这种方式其实是在初始化为数组中的任意一个角标。

public static int getMax_2(int[] arr) {
    int max = 0;

    for (int x = 1; x < arr.length; x++) {
        if(arr[x] > arr[max]) 
            max = x;
    }
    return arr[max];
}

同理，获取数组中的最小值，代码如下：

public static int getMin(int[] arr) {
    int min = 0;

    for (int x = 1; x < arr.length; x++) {
        if(arr[x] < arr[min]) 
            min = x;
    }
    return arr[min];
}

选择排序

虽然Java中的排序算法有很多，但在这里我只讲其中两种，即选择排序和冒泡排序。在这一小节中我用一个例子来详细讲解选择排序。
例，对给定数组进行排序，如{5, 1, 6, 4, 2, 8, 9}。
选择排序的原理图：
这里写图片描述

/*
对给定数组进行排序，如{5, 1, 6, 4, 2}。

0-1 0-2 0-3 0-4
1-2 1-3 1-4
2-3 2-4
3-4
*/
public static void selectSort(int[] arr) {
    for (int x = 0; x < arr.length - 1; x++) {
        for (int y = x + 1; y < arr.length; y++) {
            if(arr[x] > arr[y]) {
                int temp = arr[x];
                arr[x] = arr[y];
                arr[y] = temp;
            }
        }
    }
}

冒泡排序

在这一小节中我用一个例子来详细讲解冒泡排序。例，对给定数组进行排序，如{5, 1, 6, 4, 9, 2, 8}。
冒泡排序的原理图：
这里写图片描述

/*
对给定数组进行排序，如{5, 1, 6, 4, 2}。

0-1 1-2 2-3 3-4
0-1 1-2 2-3
0-1 1-2 
0-1
*/
public static void bubbleSort(int[] arr)
{
    for (int x = 0; x < arr.length - 1; x++)
    {
        for (int y = 0; y < arr.length - 1 - x; y++)
        {
            if (arr[y] > arr[y + 1])
            {
                int temp = arr[y];
                arr[y] = arr[y + 1];
                arr[y + 1] = temp;
            }
        }
    }
}

发现无论什么排序，都需要对满足条件的元素进行位置置换，所以可以把这部分相同的代码提取出来，单独封装成一个函数。

public static void swap(int[] arr, int a, int b) {
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

那么，冒泡排序可以写为：

public static void bubbleSort(int[] arr) {
    for (int x = 0; x < arr.length - 1; x++) {
        for (int y = 0; y < arr.length - x - 1; y++) { // -x：让每一次比较的元素减少，-1：避免角标越界
            if(arr[y] > arr[y+1]) {
                swap(arr, y, y+1);
            }
        }
    }
}

同理，选择排序也可以写为：

public static void selectSort(int[] arr) {
    for (int x = 0; x < arr.length - 1; x++) {
        for (int y = x + 1; y < arr.length; y++) {
            if(arr[x] > arr[y]) {
                swap(arr, x, y);
            }
        }
    }
}