Java基础- 数组

数组

定义

数组：相同类型数据的有序集合

声明数组变量

数据类型[] 数组名;     //首选方法
数据类型 数组名[];     //效果相同，但不是首选方法

创建数组

数据类型[] 数组名 = {1，2，3，4，5，6}        //静态初始化【声明+创建+赋值】
​
数据类型[] 数组名 = new 数据类型[数组大小]     //动态初始化【声明+创建】
//动态初始化包含默认初始化【若未赋值，int默认为0，str默认为null】

public static void main(String[] args) {
    int[] mo;           //声明一个数组
    mo = new int[3];      //创建一个数组
​
    mo[0] = 1;          //通过下标对数组进行赋值
    mo[1] = 2;
    mo[2] = 3;
​
    int sum = 0;
    for (int i = 0; i < mo.length; i++) {   //遍历数组
        sum += mo[i];
    }
    System.out.println(sum);
}

数组的基本特点

1. 数组长度确定【数组一旦被创建，大小就不能改变】

2. 数组中的元素必须是相同类型

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

4. 数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量

数组边界

1. 下标的合法区间：[0, length-1]

2. 数组下标越界异常：ArrayIndexOutBoundsException

数组使用

For-Each循环

int[] Array = {1,2,3,4,5};
for (int i : Array) {           //没有下标
    System.out.println(i);
}

数组作方法入参

//打印数组元素
public static void main(String[] args) {
    int[] array2 = {1,2,3,4,5};
    printArray(array2);
}
public static void printArray(int[] array1){
    for (int i = 0; i < array1.length; i++) {
        System.out.print(array1[i]+"\t");
}

数组作返回值

//反转数组
public static void main(String[] args) {
    int[] arrays1 = {1,2,3,4,5};
    System.out.print(Arrays.toString(reverse(arrays1)));    //输出数组
}
public static int[] reverse(int[] arrays){
    int[] result = new int[arrays.length];
    for (int i=0,j=arrays.length-1; i < arrays.length; i++,j--) {
        result[i] = arrays[j];
    }
    return result;
}

多维数组

二维数组：int[] a = new int[2][5] //可以看作两行五列的数组

public static void main(String[] args) {
    int[][] array1 = {{1,2,3},{4,5,6},{7,8,9}};
    print_array(array1);            //1 2 3 4 5 6 7 8 9
}
public static void print_array(int[][] array){
    for (int i1 = 0; i1 < array.length; i1++) {
        for (int i2 = 0; i2 < array[i1].length; i2++) {
            System.out.print(array[i1][i2]+" ");
        }
    }
}

Arrays类

• Arrays.toString() 打印数组

• Arrays.sort() 排序(升序)

• Arrays.fill() 给数组赋值

• Arrays.equals() 比较数组

• Arrays.binarySearch 查找数组元素(二分查找法)

冒泡排序

• 外层冒泡轮数，里层依次比较

• 比较数组中两个相邻元素，小者前移，下一轮比上一轮少一次排序

public static void main(String[] args) {
    int[] array = {1,2,3,89,99,56,77,21,100};
    int[] result = sort1(array);
    System.out.println(Arrays.toString(result));
}
public static int[] sort1(int[] arrays){
    for (int i = 0; i < arrays.length-1; i++) {         //外层循环
        boolean flag = false;       //通过flag标识位减少没有意义的比较
        for (int j = 0; j < arrays.length-1-i; j++) {   //内层循环
            if (arrays[j+1]<arrays[j]) {
                int value = arrays[j];
                arrays[j] = arrays[j+1];
                arrays[j+1] = value;
                flag = true;
            }
        }
        if (flag = false){
            break;
        }
    }
    return arrays;

稀疏数组

• 分析问题：由于二维数组很多值是默认值0，因此记录了很多无意义的数据

• 解决：稀疏数组

  • 记录数组一共有几行几列，有多少个有效值

  • 把有效值的行列及值信息记录在一个小规模数组中，从而缩小程序的规模

//创建一个二维数组11*11     0没有棋子   1黑棋     2白棋
int[][] array1 = new int[5][5];
array1[1][2] = 1;
array1[2][3] = 2;
System.out.println("原始数组");
for (int[] i1 : array1) {
    for (int j1 : i1) {
        System.out.print(j1+"\t");
    }
    System.out.println();
}
​
/*  结果：
原始数组
0   0   0   0   0   
0   0   1   0   0   
0   0   0   2   0   
0   0   0   0   0   
0   0   0   0   0

//转换为稀疏数组保存
//1.获取有效数字个数
int sum = 0;
for (int i2 = 0; i2 < array1.length; i2++) {
    for (int j2 = 0; j2 < array1[i2].length; j2++) {
        if (array1[i2][j2]!=0){
            sum ++;
        }
    }
}
System.out.println("有效数字个数："+sum);
/*结果：
有效数字个数：2
*/
​
//2.创建稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 5;
array2[0][1] = 5;
array2[0][2] = sum;
​
int count = 0;
for (int i3 = 0; i3 < array1.length; i3++) {
    for (int j3 = 0; j3 < array1[i3].length; j3++) {
        if (array1[i3][j3]!=0){
            count ++;
            array2[count][0] = i3;
            array2[count][1] = j3;
            array2[count][2] = array1[i3][j3];
        }
    }
}
​
//3打印稀疏数组
System.out.println("打印稀疏数组");
for (int[] i4 : array2) {
    for (int j4 : i4) {
        System.out.print(j4+"\t");
    }
    System.out.println();
}
/*结果：
打印稀疏数组
5   5   2   
1   2   1   
2   3   2

//还原稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
for (int i5 = 1; i5 < array2.length; i5++) {
        array3[array2[i5][0]][array2[i5][1]] = array2[i5][2];
}
System.out.println("还原稀疏数组");
for (int[] i5 : array3) {
    for (int j5 : i5) {
        System.out.print(j5+"\t");
    }
    System.out.println();
}
/*结果
还原稀疏数组
0   0   0   0   0   
0   0   1   0   0   
0   0   0   2   0   
0   0   0   0   0   
0   0   0   0   0