JAVASE基础--数组拓展（Arrays类，冒泡排序，稀疏数组）

Arrays类

数组的工具类java.util.Arrays

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

排序sort

Arrays.sort(a);

打印数组toString

System.out.println(Arrays.toString(a));

冒泡排序

总共有八大排序

冒泡代码比较简单，两层循环，外层冒泡轮数，里层一次比较

步骤：

1.比较数组中，两个相邻元素，如果第一个数比第二个大，我们交换他们的位置

2.每一次比较，都会产生一个最大，或者最小的数字

3.下一轮则可以少一次排序

4.依次循环直到结束

我们看到嵌套循环，应该立马可以得知时间复杂度为O(n2)。冒泡排序的时间复杂度即为O(n2)。

package method;
import java.util.Arrays;
public class array06 {
    public static void main(String[] args) {
        int[] array = {1,5,8,2,3,9,4};
        int[] sort = sort(array);//重新定义一个数组，调用排序方法，
        System.out.println(Arrays.toString(sort));
    }
    public static  int[] sort(int[] array){
        for (int i = 0; i < array.length-1; i++)
        {//  外层循环一次找到一个最小i放在最后面，再循环一次就排到最小的前面
            for (int j = 0; j < array.length-1-i; j++)
            {
            if (array[j]>array[j+1]){
                int tem = array[j];
                array[j] = array[j+1];
                array[j+1] = tem;
                }
                }
            }
            return array;
        }
    }

冒泡排序分为两层循环整个思路如下：

里层循环对相邻两数进行交换，如果希望从小到大排列，就将较大的数逐渐向后交换，里层循环完成后，就可以将最大的数交换到最末尾。

外层循环第一次将最大的数交换到最末尾，因此，第二次循环将第二大的数字交换到倒数第二的位置，因为第一次循环已经找到了最大的数字，因此只需要循环array.length-1-i次，再第二次循环中则是需要循环array.length-1-1次·，至于为什么需要-1，因为数组中包含n个元素，数组下标是从0开始，因此为了防止数组越界，需要length-1。

优化

可以定义一个布尔值flag=false，如果进入循环未进行排序，则flag=false，进行排序后给flag赋值true，当循环过程中未进行排序的情况下直接break跳出循环即可节约没必要进行的循环。

package method;
import java.util.Arrays;
public class array06 {
    public static void main(String[] args) {
        int[] array = {1,5,8,2,3,9,4};
        int[] sort = sort(array);//重新定义一个数组，调用排序方法，
        System.out.println(Arrays.toString(sort));
    }
    public static  int[] sort(int[] array){
        boolean flag = false;
        for (int i = 0; i < array.length-1; i++)
        {//  外层循环一次找到一个最小i放在最后面，再循环一次就排到最小的前面
            for (int j = 0; j < array.length-1-i; j++)
            {
                if (array[j]>array[j+1]){
                    int tem = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tem;
                    flag = true;
                }
            }
            if (flag = false){
                break;
            }
        }
        return array;
    }
}

稀疏数组

当一个数组大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

处理方式：

记录数组一共几行几列，有多少个不同值

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模（压缩节省空间）。

如下图，左边是原始数组，右边是稀疏数组：

[0]代表整个数组有几行几列几个有效数字

[1]-[8]代表第几行几列数字为几

如：第0行第3列数字是22

package method;

import com.sun.java.swing.plaf.windows.WindowsToolBarSeparatorUI;

import java.util.Arrays;

public class array09 {
    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;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=========================");
        //转换为稀疏数组格式保存
        //获取有效值个数
        int sum = 0;
        for (int i = 0; i < array1.length-1; i++) {
            for (int j = 0; j < array1.length-1; j++) {
                if (array1 [i][j] != 0){
                    sum = sum + 1;
                }
            }
        }
        System.out.println(sum);
        //创建稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2 [0][1] = 11;
        array2 [0][0] = 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-each）
        System.out.println("============");
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }System.out.println();
        }
        //遍历稀疏数组，将其输出（for）
        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("===========");
        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];
            System.out.println("还原数组");
            for (int[] ints : array3) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }System.out.println();
            }

                }
            }
        }