数据结构-数组

Java 数组

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

数组

• 数组是相同类型数据的有序集合。

• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成

• 每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们

特点：

• 长度不可变
• 元素类型一致
• 可以声明任意类型的数组
• 数组变量属于引用类型，数组也可看成对象，元素视为成员变量
• 对象存放在JVM的堆中->数组是对象->数组对象本身放在堆中！

无论数组是基本类型还是引用类型，都存在堆中！

声明数组变量

dataType[] arrayRefVar;   // java开发手册推荐

dataType arrayRefVar[];  // 兼容C/C++语法

创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

一、使用 dataType[arraySize] 创建了一个数组。

二、把新创建的数组的引用赋值给变量 arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

数组边界

下标合法区间：[0,length -1]

java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常！

数组的内存

三种初始化状态

静态初始化

创建 + 赋值

int[] a = {1,2,3,4,5,6,7,8,9};

动态初始化

包含默认初始化

int[] b = new int[10];
b[0] = 1;
// 后面未赋值的元素初始化成int的默认值0

数组的默认初始化

数组是引用类型，相当于类的实例变量，因此一经分配空间，

其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的使用

• 普通的For循环
• For-Each 循环
• 数组作方法入参
• 数组作返回值

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5, 6};
        // For-Each 循环
        for (int array : arrays) {
            System.out.print(array+" ");
        }

        System.out.println("
------------");
        // 普通的For循环
        int[] array2 = reverse(arrays);
        for (int i = 0; i < array2.length; i++) {
            System.out.print(array2[i]+" ");
        }
    }

    // 数组作方法入参
    public static int[] reverse(int a[]){
        int length = a.length;
        int[] result = new int[length];
        for (int i = 0; i < length; i++) {
            result[i] = a[length-i-1];
        }
        return result; // 数组作返回值
    }
}

多维数组

多维数组可以看成数组内嵌套数组。（套娃）

比如二维数组就是一个特殊的一维数组，它的每一个元素都是一个一维数组。

int a[][] = new int[2][3] // 声明创建一个两行三列的二维数组

稀疏数组

import java.util.Arrays;

/**
 * 稀疏数组->用小数组储存大数组
 * 比如棋盘
 */
public class SparseArray {
    public static void main(String[] args) {
        // 1.首先创建一个二维数组10*10  ->  0:空 1：黑 2：白
        int[][] chessboard = new int[10][10];
        chessboard[1][2] = 1;
        chessboard[2][3] = 2;

        System.out.println("原始棋盘：");
        for (int[] ints : chessboard) {
            System.out.println(Arrays.toString(ints));
        }


        int[][] result = toSparse(chessboard);
        System.out.println("稀疏数组：");
        for (int[] ints : result) {
            System.out.println(Arrays.toString(ints));
        }

        int[][]  chessboard2 = toChess(result);
        System.out.println("恢复棋盘：");
        for (int[] ints : chessboard2) {
            System.out.println(Arrays.toString(ints));
        }

    }

    public static int[][]  toSparse(int[][] ints) {
        // 首先统计有效个数
        int count = 0;
        for (int[] anInt : ints) {
            for (int i : anInt) {
                if (i != 0) {
                    count++;
                }
            }
        }

        // 创建稀疏数组
        int[][] result = new int[count + 1][3];

        result[0][0] = ints.length;
        result[0][1] = ints[0].length;
        result[0][2] = count;

        int k = 1;
        // 遍历棋盘 储存坐标和值
        for (int i = 0; i < ints.length; i++) {
            for (int j = 0; j < ints[i].length; j++) {
                if (ints[i][j] != 0) {
                    result[k][0] = i;
                    result[k][1] = j;
                    result[k][2] = ints[i][j];
                    k++;
                }
            }
        }
        return result;
    }

    public static int[][] toChess(int[][] ints) {
        // 棋盘大小
        int len = ints[0][0];
        int heigh = ints[0][1];
        int[][] result = new int[len][heigh];

        for (int i = 1;i<ints.length;i++) {
            int x = ints[i][0];
            int y = ints[i][1];
            int value = ints[i][2];
            result[x][y] = value;
        }
        return  result;
    }
}

小结

数组是相同数据类型的有序集合

数组也是对象，数组元素相当于对象的成员变量

数组的长度确定固定，不可变。越界报错ArrayIndexOutOfBounds