数组（二）二维数组和稀疏数组

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组 inta[][] = new int[2] [5];

解析：以上二维数组a可以看成一个两行5列的数组。

思考：多维数组的使用？

public class ArrayDemo05 {
    public static void main(String[] args) {
        //4行2列
        /*
        1,2     qrrqy[0]
        2,3     array[1]
        3,4     array[2]
        4,5     array[3]
         */
        int[][] array = {{1,2}, {2,3},{3,4},{4,5}};
       // System.out.println(array[0]);
     //   printArrays(array[0]);
        for(int i = 0; i < array.length; i ++){
            for(int j = 0 ; j < array[i].length; j++){
                System.out.println(array[i][j]);
            }
        }
        System.out.println(array.length);
        System.out.println(array[0].length);
    }

    //打印数组
    public static void printArrays(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
}
}

Arrays 类

数组的工具类java.util.Arrays

由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。

查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不使用“使用对象来调用”

数组冒泡排序

public class ArrayDemo07 {
    public static void main(String[] args) {

        int[] b = {23,33,444,1,43,343,343,455,45,909};
        int[] sort = sort(b);
        System.out.println(Arrays.toString(sort));


    }
    //冒泡排序
    //比较数组中，两个相邻的元素，如果第一个数比第二个数大，我就交换他们的位置
    //每一次比较，都会产生出一个最大，或者最小的数字
    //下一轮则可以少一次排序
    //依次循环，直到结束！

    public static int[] sort(int[] a){
        int temp= 0;//临时变量
        //外层循环，判断我们这个要走多少次；
        for(int i = 0; i < a.length-1;i++){
            //内层循环，比较判断两个数，如果第二个数，比第一个数大，则交换位置。
            for (int j = 0 ; j <a.length-1; j ++){

                if(a[j]<a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        return a;

    }
}

稀疏数组

当一个数大部分元素为0

public static void main(String[] args) {
    //创建一个二维数组 11*11 。0没有旗子，1是黑棋，2是白旗
    int[][] array1 = new int[11][11];
    array1[1][2] = 1;
    array1[2][3] = 2;
    //输出原始的数组
    System.out.println("输出原始的数组");
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            System.out.print(array1[i][j] + "\t");
        }
        System.out.println();
    }
    System.out.println("============================");
    //转换为稀疏数组保存
    //获取有效值的个数
    int sum = 0;
    for (int i = 0; i < 11; i++) {
        for (int j = 0; j < 11; j++) {
            if (array1[i][j] != 0) {
                sum++;
            }
        }
    }
    System.out.println("有效值的个数" + sum);

    //创建一个稀疏数组的数组
    int[][] array2 = new int[sum + 1][3];
    array2[0][0] = 11;
    array2[0][1] = 11;
    array2[0][2] = sum;
    //遍历二维数组，将非零的值存放到稀疏数组中
    int count = 0;
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            if (array1[i][j] != 0) {
                count++;
                array2[count][0] = i;
                array2[count][1] = j;
                array2[count][2] = array1[i][j];
            }
        }
    }
    //输出稀疏数组
    System.out.println("输出稀疏数组！");
    for (int i = 0; i < array2.length; i++) {
        System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");
    }

    System.out.println("============================");
    System.out.println("稀疏数组还原！");
    //1.读取稀疏数组的值
    int[][] array3 = new int[array2[0][0]][array2[0][1]];

    //2、给其中的元素还原它的值
    for(int i = 1; i < array2.length; i++){
        array3[array2[i][0]][array2[i][1]] = array2[i][2];

    }
    //3、打印
    System.out.println("输出原始的数组！");
    for(int[] ints:array1){
        for(int anInt:ints){
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
}