第六章 Java数组-优快云博客

一、声明数组

语法：
数组类型[ ] 变量名 = new 数组类型[数组长度]

// 定义一个整型数组，长度为5：
int[] nums = new int[5]

数组的二种初始化方法

 // 1.数组的静态初始化：创建+赋值
        int[] nums2 = {1, 2, 3, 4, 5};
       // Man[] mans = {new Man(),new Man()};//引用类型数组初始化

// 2.数组的动态初始化：如果没有给对应的数组元素赋值，会有默认值
	int[] nums3 = new int[5];
	nums3[0] = 10;
	nums3[1] = 20;
	System.out.println(nums3[0]);
	System.out.println(nums3[1]);
	System.out.println(nums3[2]);  //未赋值，打印出默认值

二、数组的基本特点

1、其长度是确定的。数组一旦被创建，它的大小是不可改变的，数组下标从0开始，一旦超过数组下标边界，会报错。
2、其元素必须是相同类型,不允许出现混合类型。
3、数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4、数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
5、数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型数组对象本身是在堆中的。

三、多维数组（本质是数组嵌套）

//二维数组，2行5列
int a[][] = new int[2][5]
//二维数组静态初始化，3行2列
int[][] array = {{1,2},{2,3},{4,5}}

四、Arrays类（Java提供的一系列数组方法）

使用方法：
step 1：引入import java.util.Arrays;
setp 2：使用：Arrays.方法名（参数）
在这里插入图片描述

//冒泡排序，手动实现（java有内置的方法，可以直接调用）
import java.util.Arrays;
public class ArrayPopsort {
    public static void main(String[] args) {
        int[] arr = {1,  3, 4, 2, 6, 10,7,12};
        int[] sort = popsort(arr);
        System.out.println("数组排序后："+ Arrays.toString(sort));
    }


    // 排序方法
    public static int[] popsort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            boolean flag = false;
            for (int j = 0; j < arr.length - 1-i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) {
                break;
            }
        }
         return arr;
    }
}

五、稀疏数组

在这里插入图片描述
右下角的数组第一列存储的是，该原始数组总共有多少列多少行多少个需要存储的数字

public class ArrayXishu {
    public static void main(String[] args) {
        // 需求：定义一个五子棋棋盘，棋盘是1个11*11的二维数组。黑子是1，白子是2，空子是0。
        int[][] arr = new int[11][11];
        arr[1][1] = 1;
        arr[2][2] = 2;
        // 打印二维数组
        for(int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        // 将这个棋盘二维数组转换为稀疏数组
        int count = 0; // 记录非0的个数
        for(int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j] != 0) {
                    count++;
                }
            }
        }
        // 1.创建一个二维数组，用来保存稀疏数组的信息
        int[][] arr2 = new int[count + 1][3];
        arr2[0][0] = arr.length;
        arr2[0][1] = arr[0].length;
        arr2[0][2] = count;
        // 2.遍历二维数组，将非0的值存放到稀疏数组中
        int index = 1;
        for(int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j] != 0) {
                    arr2[index][0] = i;
                    arr2[index][1] = j;
                    arr2[index][2] = arr[i][j];
                    index++;
                }
            }
        }
        // 打印稀疏数组
        for(int i = 0; i < arr2.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", arr2[i][0], arr2[i][1], arr2[i][2]);
        }
        // 新建一个数组保存恢复二维数组
        int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];
        for(int i = 1; i < arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];
        }
        System.out.println("恢复后的二维数组");
        for(int i = 0; i < arr3.length; i++) {
            for (int j = 0; j < arr3[i].length; j++) {
                System.out.print(arr3[i][j] + " ");
            }
            System.out.println();
        }

    }
}