JAVA----数组

数组

数组的概念

数组是一种容器，可以同时存放多个数据值，是相同数据类型元素的集合。

数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。

数组的特点

1. 数组本身是引用数据类型。
2. 数组中的多个数据，类型必须统一。
3. 数组的长度在程序运行期间不可改变。

数组的初始化

1.动态初始化（指定长度）

格式：数据类型[] 数组名称 = new 数据类型[数组长度]；

String[] str = new String[7];

使用动态初始化数组的时候，其中的元素会自动拥有一个默认值。规则如下：

如果是整数类型，那么默认为0;

如果是浮点类型，那么默认为0.0;

如果是布尔类型，那么默认为false;

如果是字符类型，那么默认为’\u0000’;

如果是引用类型，那么默认为null;

2.静态初始化（指定内容）

虽然静态初始化没有直接指定长度，但是根据元素内容可以直接推算出长度。

静态初始化其实也有默认值，只不过系统自动将默认值换成了大括号中的具体数值。

基本格式：数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，…}；

int[] num = new int[]{1,2,3,4,5};

省略格式：数据类型[] 数组名称 = {元素1，元素2，元素3, …}

int[] num = {1,2,3,4,5};

拆分格式：静态初始化和动态初始化的基本格式均可拆分，但是静态初始化的省略格式不可以拆分。

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

数组的用法

访问数组元素进行获取

int[] num = new int[]{1,2,3};
        System.out.println(num);//[I@1b6d3586
        //直接打印数组中的元素
        System.out.println(num[0]);//1
        System.out.println(num[1]);//2
        System.out.println(num[2]);//3
        //也可以将数组当中的某一个元素赋值交给变量
        int sa = num[1];
        System.out.println(sa);//2

直接打印数组名称，得到的是数组对应的，内存地址哈希值。（16进制）

访问数组元素的格式：数组名称 [索引值]

索引值：就是一个int数字，代表数组当中元素的编号。

【注意】索引值从0开始，一直到“数组的长度-1”为止。

访问数组元素进行赋值

数组名称[索引值] = 想要赋的值；

int[] num  = new int[3];
      num[1] = 30;
      System.out.println(num[1]);//30

获取数组的长度

格式：数组名称.length

这将会得到一个int数字，代表数组的长度。

int[] num  = new int[]{1,2,32,4,45,5,32,4,45,5,32,4,45,5,};
      int len = num.length;
        System.out.println(len);

int[] num  = new int[]{1,2,32,4,45,5,32,4,45,5,32,4,45,5,};
        System.out.println(num.length);	

数组运行期间，长度不可改变。

int[] num  = new int[]{1,2,32};
        System.out.println(num.length);//数组长度是3
        System.out.println(num[2]);//2号元素是32
        num = new int[5];
        System.out.println(num.length);//数组长度是5
        System.out.println(num[2]);//2号元素是 0

num = new int[5];这是将一个新的数组赋值给了原来数组的名称。

数组名称信息在内存区的栈中，而真正的数组是在堆中存储，数组名称信息中存储着真正数组的地址。

数组的遍历输出

遍历数组，说的就是对数组中的每一个元素进行逐一、挨个处理。默认的处理方式就是打印输出。

int[] array  = new int[]{1,2,32,45,34,23,434,24,34,234};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

格式：数组名称 . for i-------array.fori

二维数组

数组的数组----二维数组的每一个元素是一个一维数组

例如：

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

数组的创建

int [][]a = new int[][]{{1,2,3},{1,2,3},{1,2,3}};
int [] [] b  = {{1,2,3},{1,2,3},{1,2,3}};
int [][] c = new int[3][5];//用for循环依次赋值 1~15
int index = 1;
for (int i = 0; i < c.length; i++) {
            for (int j = 0; j < c[i].length; j++) {
                c[i][j] = index;
                index ++;
            }
        }

二维数组的迭代

int [][] b1 = new int [][]{{1,2},{3,4}};
	for(int i =0;i<b1.length;i++){
	     for(int j =0;j<b1[i].length;j++){
		System.out.print(b1[i][j]);
               }
          }

稀疏数组(sparse array)

稀疏数组是只为数组中非0元素分配存储空间的数组，内存中存储了非0元素的下标和值。

当一个数组中大部分元素的值是0或者为同一个数时，就可以使用稀疏数组。

稀疏数组的处理方法：

1.记录数组有多少行，多少列。

2.把具有不同值的元素的行列和值存储在一个小规模数组中，来缩小程序的规模。

稀疏数组的声明

非0元素的个数+1 == 稀疏数组的行数；

列数为3；

稀疏数组第一行表示原来数组的行列数及非0元素总数；

二维数组转稀疏数组：

//定义二维数组
        int[][] chessboard = new int[15][15];
        for (int i = 0; i < 15; i++) {
            for (int j = 0; j < 15; j++) {
                chessboard[i][j] = 0;
            }
        }
        chessboard[3][6] = 1;
        chessboard[5][8] = 2;
        chessboard[1][5] = 1;
        chessboard[6][6] = 2;
        //统计非0元素共有多少个
        int sum = 0;
        for (int i = 0; i < chessboard.length; i++) {
            for (int j = 0; j < chessboard[i].length; j++) {
                if (chessboard[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("非0元素的个数：" + sum);
        //声明稀疏数组   数组行为非0元素+1，列为3.
        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = chessboard.length;
        sparseArray[0][1] = chessboard[0].length;
        sparseArray[0][2] = sum;
        //利用循环将非0元素记录进稀疏数组
        int row = 1;
        for (int i = 0; i < chessboard.length; i++) {
            for (int j = 0; j < chessboard[i].length; j++) {
                if (chessboard[i][j] != 0) {
                    //将非0元素所在行传入稀疏数组第一列
                    sparseArray[row][0] = i;
                    //将非0元素所在列传入稀疏数组第二列
                    sparseArray[row][1] = j;
                    //将非0元素的值传入稀疏数组第三列
                    sparseArray[row][2] = chessboard[i][j];
                    row ++;
                }
            }

        }
        //输出稀疏数组
        for (int a = 0; a < sparseArray.length; a++) {
                System.out.print(Arrays.toString(sparseArray[a]));
            System.out.println();
        }
    }