Array

数据类型[] 名字 = new 数据类型[数据大小]

两种定义方法，即声明数组

int[] nums;//定义，声明一个数组
//两种定义方法
int nums2[];//定义

创建数组

nums = new int[10];//创建数组

声明和创建数组可以和为

int[] nums = new int[10]

数组长度

nums.length

可能出现错误、

public static void main(String[] args) {
    int[] nums = new int[10];
    System.out.println(nums[22]);
}

java.lang.ArrayIndexOutOfBoundsException

数组下表越界异常

静态初始化：创建+赋值

int[] a = {1,2,3,45,6,7,8,6};
System.out.println(a[5]);

动态初始化：包含默认初始化

默认初始值是0

int[] b = new int[10];
b[0]=10;
System.out.println(b[0]);

基本特点

其长度是确定的，数组一旦被创建，大小就是不可以改变的。

其元素必须是相同类型，不允许出现混合类型。

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

数组对象本身是在堆中的。

JDK1.5以后没有下标便利

for (int array:arrays){
    System.out.println(array);

打印数组，反转数组的方法

//打印数组元素
public static void printArray(int[] arrays) {
    for (int i = 0; i < arrays.length; i++) {
        System.out.print(arrays[i]+" ");
    }
}
//反转数组
public static int[] reverse(int[] arrays){
    int[] result = new int[arrays.length];
    //反转操作
    for (int i = 0; i < arrays.length; i++) {
        result[i] = arrays[arrays.length-1-i];
        System.out.print(result[i]+" ");
    }
    return result;
}

二维数组

相当于数组的数组

便利二维数组（便利数组的数组，用两次循环）

for (int i = 0; i < array.length; i++) {
    for (int i1 = 0; i1 < array[i].length; i1++) {
        System.out.println(array[i][i1]);

Arrays自带用法

public static void main(String[] args) {
    int[] a = {1, 5, 6, 15, 1, 51, 61, 5};
    System.out.println(a);//[I@1b6d3586

    //打印数组元素 Arrays.toString()
    System.out.println(Arrays.toString(a));

    Arrays.sort(a);//数组进行排序
    System.out.println(a[3]);
    System.out.println(Arrays.toString(a));

    Arrays.fill(a,0);
    System.out.println(Arrays.toString(a));

}
运行结果
[I@1b6d3586
[1, 5, 6, 15, 1, 51, 61, 5]
5
[1, 1, 5, 5, 6, 15, 51, 61]
[0, 0, 0, 0, 0, 0, 0, 0]

稀疏数组

即将有数字的坐标计入稀疏数组中

创建数组

int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;

输出数组

System.out.println("输出原始的数组：");
for (int[] ints:array1){
    for (int anint:ints){
        System.out.print(anint+"\t");
    }
    System.out.println();
}
输出结果
输出原始的数组：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	

转化为稀疏数组

1、获取有效个数。

int sum = 0;
for (int i = 0; i < 11; i++) {
    for (int j = 0; j < 11; j++) {
        if (array1[i][j]!=0){
            sum++;
        }
    }
    
}

2、创建一个稀疏数组的数组。

int[][] array2 = new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;

3、便利二维数组，将非零的数，存在稀疏数组中。

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[] ints:array2){
    for (int anint:ints){
        System.out.print(anint+"\t");
    }
    System.out.println();
}
*/
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");
}
运行结果
稀疏数组
11	11	2	
1	2	1	
2	3	2

还原数组

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:array3){
    for (int anint:ints){
        System.out.print(anint+"\t");
    }
    System.out.println();
}
运行结果
输出还原的数组：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	

冒泡排序

public static void sort(int[] array) {
    int temp=0;
    //外层循环，判断进行多少次
    for (int i = 0; i < array.length; i++) {
        //内层循环，判断两个数
    for (int j = 0; j < array.length-1; j++) {
        if (array[j+1]>array[j]){
            temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
            flag = true;
        }
    }

}
}

改善冒泡排序

public static void sort(int[] array) {
    int temp=0;
    //外层循环，判断进行多少次
    for (int i = 0; i < array.length; i++) {

        boolean flag = false;
        //内层循环，判断两个数
    for (int j = 0; j < array.length-1; j++) {
        if (array[j+1]>array[j]){
            temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
            flag = true;
        }//如果if没有执行，即flag=false。则说明后面的数顺序没有问题，可以直接跳出循环，避免没必要的比较。
    }
    if (flag==false){
        break;
    }
}
}