数组

数组的创建

创建分为三步
1、声明一个数组
2、分配一个空间
3、赋值

int[] arr;
arr = new int[10];
arr[0] = 1;

也可通过以下方式创建数据

int[] arr =  new int[10];
arr[0] = 1;

int[] arr = {1,2};

还有一种声明的写法，为int arr[]，但使用不多

数组的使用

一般都是通过for循环或者增强for循环来使用

int[] arr = {1,2};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

for (int i : arr) {
  System.out.println(arr[i]);
}

多维数组

格式以二维数组为例，更多维可参考二维数据，规律是一样的

二维数据创建如下
int[][] arr3 = new int[2][2];
arr3[0][0] = 1;

可通过双层for循环进行遍历
for (int i = 0; i < arr3.length; i++) {
    for (int j = 0; j < arr3[i].length; j++) {
        System.out.println(arr3[i][j]);
    }
}

稀疏数组

稀疏数组是二维数组,用于记录大量重复数值的二维数组的压缩数组
稀疏数组的第一行的值分别为原需要被压缩的数组的大小以及需要保存的值的数量，从第二行开始则为需要保存的值的在原数组的位置以及具体的值(这块我从来没用过，感觉之前也不知道)

package com.wang.base;

/**
 * @author wang
 * @version 1.0
 * @since 1.8
 */
public class Demo {
    public static void main(String[] args) {
        //无效数字的值
        int invalidNumber = 1;
        //原数组的声明和初始化
        int[][] arr = new int[10][10];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = invalidNumber;
            }
        }
        arr[0][0] = 2;
        arr[3][2] = 2;
        arr[5][6] = 3;
        arr[6][6] = 4;
        print2dArray(arr);
        //需要被压缩的数组转稀疏数组
        int[][] arr1 = arrayToSparseArray(arr,invalidNumber);
        print2dArray(arr1);
        //稀疏数组转会原数组
        int[][] arr2 = sparseArraytoArray(arr1,invalidNumber);
        print2dArray(arr2);
    }

    /**
     *
     * @param array 需要被压缩的数组
     * @param invalidNumber  无效数字的值
     * @return  稀疏数组
     */
    public static int[][] arrayToSparseArray(int[][] array,int invalidNumber) {
        //有效数字个数
        int count = 0;
        //第一次循环，用于找出有效数字的个数，从而依此创建稀疏数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != invalidNumber){
                    count++;
                }
            }
        }
        //创建稀疏数组，并给第一行附上对应的值
        int[][] sarseArray = new int[count+1][3];
        //原数组的行数
        sarseArray[0][0] = array.length;
        //原数组的列数
        sarseArray[0][1] = array[0].length;
        //有效数字的个数
        sarseArray[0][2] = count;

        //有效数字在稀疏数组中的行数
        int count1 = 0;
        //第二次循环，用于找出具体的有效数字，并将其存储至稀疏数组中
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != invalidNumber){
                    //找到一次有效数据，稀疏数组的存储位置行数加1
                    count1++;
                    //原数组的行数
                    sarseArray[count1][0] = i;
                    //原数组的列数
                    sarseArray[count1][1] = j;
                    //原数组对应的值
                    sarseArray[count1][2] = array[i][j];
                }
            }
        }
        return sarseArray;
    }

    /**
     *
     * @param sparseArray 稀疏数组
     * @param invalidNumber  无效数字的值
     * @return  还原数组
     */
    public static int[][] sparseArraytoArray(int[][] sparseArray,int invalidNumber) {
        //通过从稀疏数组中取第一行的值来创建数组
        int[][] array = new int[sparseArray[0][0]][sparseArray[0][1]];
        //先将所有的值赋为默认值
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = invalidNumber;
            }
        }
        //将有效的数据放入对应位置中
        for (int i = 1; i < sparseArray.length; i++) {
            array[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return array;
    }

    /**
     *
     * @param arr 需要被打印的二维数组
     */
    public static void print2dArray(int[][] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

Arrays工具类

没怎么用过，知道toString()打印、sort()排序、toList()数组转list、copyOf()复制，工作中list用的比较多，可能数组转list会偶尔用用，这块的互转等后面集合的时候再都写一下

数组最典型的问题当属排序，最经典的问题当属冒泡排序，排序这块回头可以单独写一份随笔，方便查看，虽然这块我在工作中也没怎么用到过，毕竟做的业务比较简单