1、是什么？
比如有一个 11 * 11 的五子棋盘，我们要用程序模拟，那肯定就是二维数组。然后用1表示黑子，2表示白子，假如现在棋盘上只有一个黑子一个白子，那么也就是这个二维数组中只有一个1，一个2，其他都是无意义并不代表任何棋子的0，如下：
0 0 0 0 0 0 0 0 0 0 0  0 0 0 0 1 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ……
当一个数组中大部分元素是0时，或者为同一个值时，就可以用稀疏数组来保存该数组。为什么要这么做？因为可以节省空间。
2、怎么用？
记录原数组有几行几列，有多少个不同的值
把具有不同值的元素的行列及值记录在一个小规模数组中，这个小规模的数组就叫稀疏数组
3、案例：
现有如下的 6 * 7 的原始数组：
0   0   0   22   0   0   15 0   11  0   0    0   17   0 0   0   0  -6    0   0    0 0   0   0   0    0   39   0 91  0   0   0    0   0    0 0   0   28  0    0   0    0
首先稀疏数组第一行第一列是记录元素数组有几行，第一行第二列是记录原始数组有几列，第一行第三列是记录原始数组有几个不同的值(除了0)。所以稀疏数组一行应该是：
行    列    值 6     7     8
稀疏数组第二行开始，每行记录的是，原始数组中非0值所在的行、所在的列、值的大小。比如第二行要记录22在原始数组中的行、列、值，那么稀疏数组第二行就是：
行    列    值 0     3     22
然后用此方法记录15、11、17、-6、39、91、28的相关信息，所以最终由该原始数组转化出来的稀疏数组就是：
行    列    值 6     7     8 0     3     22 0     6     15 1     1     11 1     5     17 2     3     -6 3     5     39 4     0     91 5     2     28
这样就把一个 6 * 7 的数组变成了一个 9 * 3 的数组，达到了压缩的效果。
4、原始数组与稀疏数组相互转换思路：
原始数组转稀疏数组：
遍历二维数组得到有效数组的个数count；
根据count就可以创建稀疏数组      int[count + 1][3];
将有效数组存入稀疏数组
稀疏数组转原始数组：
读取稀疏数组第一行，根据第一行数组可以知道原始数组有几行几列，然后创建原始数组；
读取稀疏数组后几行的数组，赋值给原始数组即可
5、代码实操：
public class sparsearray {     public static void main(string[] args){         // 创建一个 11 * 11的原始数组         int[][] arr1 = new int[11][11];         arr1[1][2] = 1;         arr1[2][3] = 2;         // 原始数组转稀疏数组         // 1. 遍历，得到非0数据的个数以及所在的行列         int count = 0;         map<string, integer> map = new hashmap<>();         for (int i = 0; i < arr1.length; i++) {             for (int j = 0; j < arr1[i].length; j++) {                 if (arr1[i][j] != 0){                     count ++;                     map.put(i+ , + j, arr1[i][j]);                 }             }         }         // 2. 创建稀疏数组         int[][] sparsearr = new int[count + 1][3];         sparsearr[0][0] = arr1.length;         sparsearr[0][1] = arr1[0].length;         sparsearr[0][2] = count;         // 3. 给稀疏数组赋值         int row = 1;         for (string key : map.keyset()){             string[] ij = key.split(,);             int i = integer.parseint(ij[0]);             int j = integer.parseint(ij[1]);             sparsearr[row][0] = i;             sparsearr[row][1] = j;             sparsearr[row][2] = map.get(key);             row ++;         }         // 4. 遍历稀疏数组         for (int i = 0; i < sparsearr.length; i++) {             for (int j = 0; j < sparsearr[i].length; j++) {                 system.out.print(sparsearr[i][j] +    );             }             system.out.println(\r\n);         }         // 稀疏数组恢复原始数组         // 1. 根据第一行第一列第二列创建出原始数组         int i = sparsearr[0][0];         int j = sparsearr[0][1];         int[][] arr2 = new int[i][j];         // 2. 给原始数组赋值         for (int k = 1; k < sparsearr.length; k++) {             int x = sparsearr[k][0];             int y = sparsearr[k][1];             int val = sparsearr[k][2];             arr2[x][y] = val;         }         // 3. 遍历转换的数组         for (int a = 0; a < arr2.length; a++) {             for (int b = 0; b < arr2[a].length; b++) {                 system.out.print(arr2[a][b] +    );             }             system.out.println(\r\n);         }     } }
上面的代码就实现了原始数组与稀疏数组的相互转换，灵活运用稀疏数组，可以节省运行内存，提高程序性能。
以上就是java怎么实现原始数组与稀疏数组相互转换的详细内容。