Day09 java数组：Arrays类，冒泡排序，稀疏数组

Arrays

public static void main(String[] args) {
    int[] a={1,2,5,3,8,1};
    System.out.println(Arrays.toString(a));
    Arrays.sort(a);//数组排序
    System.out.println(Arrays.toString(a));
    Arrays.fill(a,0);//数组填充
    System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0, 0]
    Arrays.fill(a,2,4,0);//数组填充,第二位到第四位，包头不包尾
    System.out.println(Arrays.toString(a));//[1, 1, 0, 0, 5, 8]
}

冒泡排序

    public static void main(String[] args) {
        //冒泡排序
        //1.比较数组中，两个相邻的元素，如果第一个比第二个大，我们就交换位置
        //2.每一次比较，都会产生一个最大的，或者最小的数字；
        //3.下一轮则可以少一次排序
        //4.一次循环，直接结束

        int[] array = {1, 2, 5, 3, 8, 1};
        int temp = 0;
        //外层循环判断我们要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag=false;//通过flag标识位减少没有意义的比较
            //内层循环，比较判断两个数，如果第一个数比第二个数字大，则交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j+1]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag=true;
                }
            }
            if (flag==false)
            {
                break;
            }

        }
        System.out.println(Arrays.toString(array));
    }

稀疏数组

public static void main(String[] args) {
    //1.创建一个二维数组11*11 0：没有棋子，1.黑棋2.白棋
    int[][] array1 = new int[11][11];
    array1[1][2] = 1;
    array1[2][3] = 2;
    //输出原始数组
    for (int[] a1 : array1) {
        for (int a2 : a1) {
            System.out.print(a2 + "\t");
        }
        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);

    //2.创建一个稀疏数组的数组
    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];//值
            }
        }
    }
    //输出稀疏数组
    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];
    }
    //打印
    for (int[] a1 : array3) {
        for (int a2 : a1) {
            System.out.print(a2 + "\t");
        }
        System.out.println();
    }
}