数组

定义

相同类型数据的有序集合

声明创建

• 必须先声明数组，才能使用(动态初始化)

int[] nums;//定义  java
int nums2[];//定义  c/c++   
都可以用，首选第一个

• 声明后要创建

nums = new int[10];(默认初始化，0或null)

• 静态初始化: 创建+赋值

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

四个基本特点

• 长度是确定的，一旦被创建，大小不可变

• 数组中元素为相同类型

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

• 数组变量是引用类型，数组可以看成是对象，每个元素相当于该对象的成员变量。

  数组对象本身在堆中

数组边界

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

如果越界就会报错：ArrayIndexOutOfBoundsException(数组下标越界异常)

小结

• 数组是相同数据类型的有序集合
• 数组也是对象，数组元素相当于对象的成员变量
• 数组的长度是确定的，不可变的。如果越界，就会报错

数组使用

• 普通的for循环
• for-each循环
• 数组作为方法的参数
• 数组作为返回值

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

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

Array类

• toString 用于打印

• sort 排序

• fill 赋值

• equals 比较是否相等

• binarySearch 查找

  更多看jdk8帮助文档

冒泡排序

排序后续再新开随笔

稀疏数组

• 当一个数组的大部分元素为0，或为同一值时，可以使用稀疏数组来保存该数组

• 处理方法：

  • 记录数组一共有几行几列，有多少个不同值
  • 把不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

• 下图：左边为原始数组，右边是稀疏数组

小练习：

/**
 * @version: java version 1.8
 * @Author: Mr Orange
 * @description:
 * @date: 2024-07-02 13:35
 */
public class Nums {
    public static void main(String[] args) {
        //创建新的数组
        int[][] arr1 = new int[11][11];
        arr1[0][0] = 1;
        arr1[3][2] = 2;
        arr1[6][3] = 1;
        arr1[7][4] = 2;
        System.out.println("===============================");
        System.out.println("原始数组");
        //打印数组
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j] + "  ");
            }
            System.out.println();
        }
        System.out.println("===============================");
        System.out.println("稀疏数组：");
        int[][]xishu =  xiShu(arr1);
        System.out.println("还原数组");
        restore(xishu);



    }
    public static int[][] xiShu(int[][] arr1) {
        //计算有多少个不同数据
        int count = 0;
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                if (arr1[i][j] != 0) {
                    count++;
                }
            }
        }
        //创建稀疏数组
        int[][] arr2 = new int[count+1][3];
        //给第一行赋值
        arr2[0][0] = arr1.length;
        arr2[0][1] = arr1[0].length;
        arr2[0][2] = count;
        //将不同数据的行、列、值，记录到稀疏数组中
        int flag = 1;
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                if (arr1[i][j] != 0) {
                    arr2[flag][0] = i;
                    arr2[flag][1] = j;
                    arr2[flag][2] = arr1[i][j];
                    flag++;
                }
            }
        }
        //打印数组
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.print(arr2[i][j] + "  ");
            }
            System.out.println();
        }
        System.out.println("===============================");
        return arr2;
    }
    public static int[][] restore(int[][] arr2) {
        //还原
        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];
        }
        //打印数组
        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();
        }
        return arr3;
    }
}