数据结构与算法---数组

数据结构与算法—数组

1. 基本概念
同一种类型数据的集合。数组就是一个容器，用来存放相同类型的数据的容器。
2. 数组的好处
数组的最大好处就是能都给存储进来的元素自动进行编号. 注意编号是从0开始。方便操作这些数据。
3. java中的数组
3.1 Java中数组的定义
Java 中定义数组的语法有两种：

    type arrayName[];
    type[] arrayName;

type 为Java中的任意数据类型，包括基本类型和组合类型，arrayName为数组名，必须是一个合法的标识符，[ ] 指明该变量是一个数组类型变量。例如：

    int demoArray[];
    int[] demoArray;

这两种形式没有区别，使用效果完全一样，读者可根据自己的编程习惯选择。
与C、C++不同，Java在定义数组时并不为数组元素分配内存，因此[ ]中无需指定数组元素的个数，即数组长度。而且对于如上定义的一个数组是不能访问它的任何元素的，我们必须要为它分配内存空间，这时要用到运算符new，其格式如下：

  arrayName=new type[arraySize];

其中，arraySize 为数组的长度，type 为数组的类型。如：

   demoArray=new int[3];

为一个整型数组分配3个int 型整数所占据的内存空间。
通常，你可以在定义的同时分配空间，语法为：

    type arrayName[] = new type[arraySize];

例如：

    int demoArray[] = new int[3];

3.2 java中数组的初始化
我们可以在声明数组的同时进行初始化（静态初始化），也可以在声明以后进行初始化（动态初始化）。例如：

    // 静态初始化
    // 静态初始化的同时就为数组元素分配空间并赋值
    int intArray[] = {1,2,3,4,5,6};
    String stringArray[] = {"java数组", "test", "demo"};
    // 动态初始化
    float floatArray[] = new float[3];
    floatArray[0] = 3.0f;
    floatArray[1] = 15.8f;
    floatArray[2] = 33F;

3.3 java中数组的引用
可以通过下标来引用数组：

    arrayName[index];

与C、C++不同，Java对数组元素要进行越界检查以保证安全性。
每个数组都有一个length属性来指明它的长度，例如 intArray.length 指明数组 intArray 的长度。
【示例】写一段代码，要求输入任意5个整数，输出它们的和。

import java.util.*;
public class Test1 {
    public static void main(String[] args) {
        int arr[] = new int[5];
        long total = 0;
        int len = arr.length;
        // 给数组元素赋值
        System.out.print("请输入" + len + "个整数，以空格为分隔：");
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < len; i++) {
            arr[i] = sc.nextInt();
        }
        // 计算数组元素的和
        for (int i = 0; i < len; i++) {
            total += arr[i];
        }
        System.out.println("所有数组元素的和为：" + total);
    }
}

运行结果：
请输入5个整数，以空格为分隔：1 20 36 17 68
所有数组元素的和为：142
3.4 数组的遍历
实际开发中，经常需要遍历数组以获取数组中的每一个元素。最容易想到的方法是for循环，例如：

    int arrayDemo[] = {1, 2, 3, 8, 16, 55, 90};
    for(int i=0,len=arrayDemo.length; i<len; i++){
    System.out.println(arrayDemo[i] + ", ");
    }

输出结果：
1, 2, 3, 8, 9, 55, 90,
不过，Java提供了”增强版“的for循环，专门用来遍历数组，语法为：

    for( arrayType varName: arrayName ){
    // Some Code
    }

arrayType 为数组类型（也是数组元素的类型）；varName 是用来保存当前元素的变量，每次循环它的值都会改变；arrayName 为数组名称。
每循环一次，就会获取数组中下一个元素的值，保存到 varName 变量，直到数组结束。即，第一次循环 varName 的值为第0个元素，第二次循环为第1个元素……例如：

    int arrayDemo[] = {1, 2, 3, 8, 16, 55, 90};
    for(int x: arrayDemo){
    System.out.println(x + ", ");
    }

输出结果与上面相同。
这种增强版的for循环也被称为”foreach循环“，它是普通for循环语句的特殊简化版。所有的foreach循环都可以被改写成for循环。
但是，如果你希望使用数组的索引，那么增强版的 for 循环无法做到。
3.5 二维数组
二维数组的声明、初始化和引用与一维数组相似：

    int intArray[ ][ ] = { {1,2}, {3,4}, {5,6} };
    int a[ ][ ] = new int[4][3];
    a[0][0] = 12;
    a[0][1] = 34;
    // ......
    a[1][2] = 93;
    // ......

Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。例如：

    int intArray[ ][ ] = { {1,2}, {2,3}, {3,4,5} };
    int a[ ][ ] = new int[2][ ];
    a[0] = new int[3];
    a[1] = new int[5];

【示例】通过二维数组计算两个矩阵的乘积。

import java.util.*;

public class Test1 {
    public static void main(String[] args) {
        // 第一个矩阵（动态初始化一个二维数组）
        int a[][] = new int[2][3];
        // 第二个矩阵（静态初始化一个二维数组）
        int b[][] = {{1, 2, 3, 8}, {3, 9, 6, -3}, {2, 9, -5, -4}};
        // 结果矩阵
        int c[][] = new int[2][4];
        // 初始化第一个矩阵
        for (int i = 0; i < 2; i++)
            for (int j = 0; j < 3; j++)
                a[i][j] = (i + 1) * (j + 2);
        // 计算矩阵乘积
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 4; j++) {
                c[i][j] = 0;
                for (int k = 0; k < 3; k++)
                    c[i][j] += a[i][k] * b[k][j];
            }
        }
        // 输出结算结果
        for(int i=0; i<2; i++){
            for (int j=0; j<4; j++)
                System.out.printf("%-5d", c[i][j]);
            System.out.println();
        }
    }
}

运行结果：
19 67 4 -9
38 134 8 -18
几点说明：
上面讲的是静态数组。静态数组一旦被声明，它的容量就固定了，不容改变。所以在声明数组时，一定要考虑数组的最大容量，防止容量不够的现象。
如果想在运行程序时改变容量，就需要用到数组列表(ArrayList，也称动态数组)或向量(Vector)。
正是由于静态数组容量固定的缺点，实际开发中使用频率不高，被 ArrayList 或 Vector 代替，因为实际开发中经常需要向数组中添加或删除元素，而它的容量不好预估。
3.6 数组的常见异常
数组中最常见的问题：
1. NullPointerException 空指针异常
原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。\
2. ArrayIndexOutOfBoundsException 索引值越界。
原因：访问了不存在的索引值。一数组角标越界异常: 注意：数组的角标从0开始。

public static void main(String[] args) {
    int[] x = { 1, 2, 3 };
    System.out.println(x[3]);
    //java.lang.ArrayIndexOutOfBoundsException
}

3. 空指针异常:

public static void main(String[] args) {
    int[] x = { 1, 2, 3 };
    x = null;
    System.out.println(x[1]);
    // java.lang.NullPointerException
}

4. 数组的内存结构
我们定义如下数组:

int[] arr = new int[4];

则其内存结构如下图所示：