数组

数组的定义

• 数组就是相同类型的若干个数据组成，有序排列的数据
• 每一个数据为一个数组元素，可以通过下标来访问它

数组声明创建

• 声明创建数组:

datatype[] ArrayRefvar;//推荐
datatype ArrayRefvar[];

• new语句创建数组:

Datatype[] ArrayRefvar = new Datatype[ArraySize];

数组初始化

静态初始化

int[] a = {1,2,3,4,5,6,7,8};

动态初始化

int[] b= new int[10];
b[0]=10;

数组边界

• 数组是相同类型的有序集合

• 数组也是对象

• 数组长度是确定的,如果越界就会报错

数组的使用

• For循环
• For-Each循环
• 数组作为方法入参
• 数组作为返回值

数组使用的示例：

public static void main(String[] args) {
    int[] a = {1,2,3,4,5};
    //jDK1.5,没有下标
    for (int i : a) {
        System.out.println(i);
    }
    //定义数组B = 数组a的反转
    int[] b= reverse(a);
    PrintArray(a);
    PrintArray(b);
}
//打印数组元素
public static void PrintArray(int[] array){
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i]+" ");
    }
}
//反转数组
public  static int[] reverse(int[] arrays){
    int[] result= new int[arrays.length];
    //反转的操作
    for (int i = arrays.length - 1,j=0; i >= 0; i--,j++) {
        result[j]=arrays[i];
    }
    return result;
}

二维数组

• 数组中的数组,数组中又包含数组

二维数组

int[][] sums=new int[5][2]; 

二维数组的使用

public static void main(String[] args) {
    int[][] array = {{1, 2}, {3, 4}, {5, 6}};
    //打印二位数组
    for (int i = 0; i < array.length; i++) {
        for (int i1 = 0; i1 < array[i].length; i1++) {
            System.out.println(array[i][i1]);
        }
    }
}

Arrays 类

• 数组的工具类 java.util.Arrays
• Arrays类可以对数据对象进行一些基本的操作
• Arrays类方法中都是static,可以直接调用,而不用new创建对象调用

冒泡排序

• 冒泡排序，俩层循环，外层冒泡轮数，内层依次比较，江湖中人人皆知
• 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为0(n2)

冒泡排序代码

//冒泡排序
public static int[] sort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        for (int i1 = 0; i1 < array.length - 1; i1++) {
            if (array[i1] > array[i1 + 1]) {
                int min = array[i1 + 1];
                array[i1 + 1] = array[i1];
                array[i1] = min;
            }
        }
    }
    return array;
}

稀疏数组

二维数组有重复的0,为了更好的保存数组便有了稀疏数组

//创造一个稀疏数组
int[][] ints=new int[不是0的个数][3];
//ints[0][0]=二位数组的x
//ints[0][1]=二位数组的y
//ints[0][3]=不是0的个数
//ints[][0] 行/x
//ints[][1]	列/y
//ints[][2]	值

二维数组转稀疏数组：

//将二维数组转为稀疏数组
public static int[][] to(int[][] array){
    //找到不是0的个数
    int sum = 0;
    for (int i = 0; i < array.length; i++) {
        for (int i1 = 0; i1 < array[i].length; i1++) {
            if (array[i][i1] != 0) {
                sum++;
            }
        }
    }

    //创建一个稀疏数组
    int[][] arrays1 = new int[sum + 1][3];
    arrays1[0][0] = array.length;
    arrays1[0][1] = array[0].length;
    arrays1[0][2] = sum;

    //遍历二维数组,将非零的值，存放在稀疏数组中
    int count = 0;
    for (int i = 0; i < array.length; i++) {
        for (int i1 = 0; i1 < array[i].length; i1++) {
            if (array[i][i1]!=0){
                count++;
                arrays1[count][0]=i;
                arrays1[count][1]=i1;
                arrays1[count][2]=array[i][i1];
            }
        }
    }
    return arrays1;
}

稀疏数组转二维数组

//将稀疏数组转为二维数组
public static int[][] ToTwoDimensional(int[][] array){
    int[][] result=new int[array[0][0]][array[0][1]];
    for (int i = 1; i < array.length; i++) {
        result[array[i][0]][array[i][1]]=array[i][2];
    }
    return result;
}