Java数组的基础知识

为什么要引入数组？

需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。

通过上面的分析，数组是什么？有什么特点呢？

数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致
数组概念：数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式

格式1：数据类型[] 数组名;
格式2：数据类型数组名[];
注意：这两种定义做完了，数组中是没有元素值的。如何对数组的元素进行初始化呢?

数组初始化概述

Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

数组的初始化方式

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
动态初始化格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。

int[] arr = new int[3];

解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
静态初始化格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

int[] arr = new int[]{1,2,3};

解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
简化写法：

int[] arr = {1,2,3};

数组操作常见的两个问题

数组索引越界
ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。
空指针异常
NullPointerException
数组引用没有指向实体，却在操作实体中的元素时。

面向对象编程方式

自定义增删改查的数组类

/**
 * 自定义的数组类
 */
public class MyArray {
    private long[] arr;
    //表示有效数据的长度
    private int elements;

    public MyArray() {
        arr = new long[50];
    }

    public MyArray(int maxSize) {
        arr = new long[maxSize];
    }

    /**
     * 添加数据
     */

    public void insert(long value) {
        arr[elements] = value;
        elements++;
    }

    /**
     * 显示数据
     */
    public void display() {
        System.out.print("[");
        for (int i = 0; i < elements; i++) {
            if (i != elements - 1) {
                System.out.print(arr[i] + ",");
            } else {
                System.out.print(arr[i]);
            }

        }
        System.out.println("]");
    }

    /**
     * 查找数据,根据值查找索引
     */
    public int search(long value) {
        int i;
        for (i = 0; i < elements; i++) {
            if (value == arr[i]) {
                break;
            }
        }

        if (i == elements) {
            return -1;
        } else {
            return i;
        }
    }

    /**
     * 根据索引查找值
     */

    public long get(int index) {
        if (index >= elements || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            return arr[index];
        }
    }

    /**
     * 删除数据
     */
    public void delete(int index) {
        if (index >= elements || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            for (int i = index; i < elements; i++) {
                arr[i] = arr[i + 1];
            }
            elements--;
        }
    }

    /**
     * 更新数据
     */

    public void change(int index, long newValue) {
        if (index >= elements || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            arr[index] = newValue;
        }
    }

    /**
     * 添加元素并自动排序
     */
    public void insertByOrder(long value) {
        int i;
        for (i = 0; i < elements; i++) {
            if (arr[i] > value) {
                break;
            }
        }

        for (int j = elements; j > i; j--) {
            arr[j] = arr[j - 1];
        }

        arr[i] = value;
        elements++;
    }

    /**
     * 二分查找（前提：数组有序）
     */

    public int binarySearch(long value) {
        int middle = 0;
        int low = 0;
        int pow = elements;

        while (true) {
            middle = (low + pow) / 2;
            if (arr[middle] == value) {
                return middle;
            } else if (low > pow) {
                return -1;
            } else {
                if (arr[middle] > value) {
                    pow = middle - 1;
                } else {
                    low = middle + 1;
                }
            }
        }
    }

}

二分查找详细介绍可参考这里

Java算法之数组