[数据结构与算法]java 数组

java 数组

数组定义

1. 数组是相同类型数据的有序集合
2. 每个数据称为数组元素，每个数组元素可以通过下标来访问。

数组声明

数组必须先声明，才能在程序中使用

/*
1. int[] nums; // 首选的方法
2. int nums[];
*/

数组声明后，采用new操作符创建数组

/*
dataType[] array = new dataType[arraySize];
*/

三种初始化及内存分析

堆

1. 存放 new 的对象和数组。
2. 可以被所有的线程共享，不会存放别的对象引用。

栈

1. 存放基本变量类型（包含这个基本变量类型的具体数值）
2. 引用对象的变量（存放这个引用在堆里面的具体地址）

方法区

1. 可以被所有线程共享
2. 包含所有 class 和 static 变量

/*
1. 静态初始化，声明+创建+初始化
int[] a = {1,2,3,4,5}; // {} 表示这是一个数组
2. 动态初始化，创建与初始化分开
int[] nums = new int[5];
 nums[0] = 1;
 nums[1] = 2;
 nums[2] = 3;
 nums[3] = 4;
 nums[4] = 5;
*/

数组使用

public class Demo1 {
    public static void main(String[] args) {
       // 静态初始化
        int[] nums = new int[5];
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
}

1. 数组可以作为方法参数
2. 数组可以作为方法的返回值
3. 可以使用foreach遍历数组

public class Demo1 {
    public static void main(String[] args) {
      int[] nums = {1,2,3,4,5};
      for(int num:nums){
          System.out.println(num);
      }
    }
}

多维数组

int[][] nums = {{1,2},{3,4}};

Arrays类

操作数组的工具类

稀疏数组

public class array {
    public static void main(String[] args) {
        // 创建一个7*7数组
        int[][] nums = new int[7][7];
        // 打印数组
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[0].length; j++) {
                System.out.print(nums[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("=================================");
        // 动态初始化
        nums[3][4] = 7;
        nums[5][6] = 1;
        // 打印数组
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[0].length; j++) {
                System.out.print(nums[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("=================================");
        // 稀疏存储
        int num = 0; // 用于统计非零元素个数
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[0].length; j++) {
                if(nums[i][j] != 0){
                    num++;
                }
            }
        }
        // 稀疏矩阵，第一行存储原矩阵行数、列数、非零元素个数
        // 其余行存储非零元素，行号，列号，值
        int[][] sparseMatrix = new int[num+1][3];
        // 初始化第一行
        sparseMatrix[0][0] = nums.length;
        sparseMatrix[0][1] = nums[0].length;
        sparseMatrix[0][2] = num;
        int remain = sparseMatrix[0][2];
        for (int i = 0; i < nums.length; i++) {
            if(remain==0){
                break;
            }
            for (int j = 0; j < nums[0].length; j++) {
                if(nums[i][j] != 0){
                    sparseMatrix[remain][0] = i;
                    sparseMatrix[remain][1] = j;
                    sparseMatrix[remain][2] = nums[i][j];
                    remain--;
                }
            }
        }
        // 打印稀疏数组
        for (int i = 0; i < sparseMatrix.length; i++) {
            System.out.print(sparseMatrix[i][0]+" ");
            System.out.print(sparseMatrix[i][1]+" ");
            System.out.print(sparseMatrix[i][2]+" ");
            System.out.println();
        }
        System.out.println("=================================");
        // 稀疏数组还原
        int[][] result = new int[sparseMatrix[0][0]][sparseMatrix[0][1]];
        // 动态初始化
        for (int i = 1; i <= sparseMatrix[0][2]; i++) {
            result[sparseMatrix[i][0]][sparseMatrix[i][1]] = sparseMatrix[i][2];
        }
        // 打印数组
        for (int i = 0; i < result.length; i++) {
            for (int j = 0; j < result[0].length; j++) {
                System.out.print(result[i][j]+" ");
            }
            System.out.println();
        }