java数组

目录

一、数组概念

二、数组的声明与初始化

三、数组操作示例

四、数组属性与注意事项

五、内存结构分析

六、常见操作

七、二维数组 

八、稀疏数组

---

一、数组概念

数组是 Java 中用于存储相同类型数据的有序集合，具有以下特性：

• 类型一致性：所有元素必须属于同一数据类型

• 有序性：元素按顺序排列，通过索引访问

• 长度固定：创建后无法改变容量

二、数组的声明与初始化

声明数组

// 推荐写法
int[] numbers;

初始化方式：动态初始化

numbers = new int[10]; // 分配 10 个int空间，默认值为0
//静态初始化分配空间之后，空间将不可改变，即使空间内无值，也会有默认值对空间进行占用

  静态初始化

int[] num2 = new int[]{1,2,3,4,5}; 
//直接赋值的数组长度不限，数组自动识别长度，一旦初始化，内容直接赋值给数组

简化写法

int[] num3 = {1,2,3,4,5}; // 自动推断长度

三、数组操作示例

 赋值与访问

numbers[0] = 1; // 索引从0开始
numbers[1] = 2;
// ...
System.out.println(numbers[0]); // 输出1

遍历数组

int sum = 0;
for (int i = 0; i < numbers.length; i++) {
    sum += numbers[i];
}
System.out.println("总和: " + sum); // 输出55（1+2+...+10）

四、数组属性与注意事项

数组长度：通过 数组名.length 获取长度：

System.out.println(numbers.length); // 输出10

索引范围

• 有效索引：0 到 length-1（索引最大值）

• 越界错误：

// 会抛出 ArrayIndexOutOfBoundsException
System.out.println(numbers[10]); 

默认值

未赋值的数组元素会有默认值：

• 数值类型：0

• boolean：false

• 对象类型：null

五、内存结构分析

int[] array= new int[10];

java内存有：
        堆：用于存放new出来的对象和数组    可以被所有的线程共享，不会存放别的对象引用
        栈：存放基本变量类型（会包含这个基本类型的具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址）
        区：方法被所有的线程共享，包含了所有的class和static变量

        声明的时候这个数组本不存在，通过new关键字去创建数组的时候，这个数组才产生，指定长度，并且赋值，不赋值的话就是默认元素 

六、常见操作

复制数组

int[] copy = Arrays.copyOf(numbers, numbers.length);

数组的反转 

package Total_review;

public class a {
        public static void reverse(int[] arr) {
            int left = 0;
            int right = arr.length - 1;
            while (left < right) {
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                left++;
                right--;
            }
        }

        public static void main(String[] args) {
            int[] numbers = {1, 2, 3, 4, 5};
            reverse(numbers);
            for (int num : numbers) {
                System.out.print(num + " ");
            }
        }

}

 排序

Arrays.sort(numbers); // 升序排列

冒泡排序 

        int[] arr = {1, 64, 54, 9848, 498, 498456, 19889, 198};

        // 外层循环控制排序的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // 内层循环用于比较相邻元素并交换位置
            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;
                }
            }
        }

顺序查找

        顺序查找适用于未排序的数组，通过遍历数组逐个比较元素。

public class SearchExample {
    public static int Search(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 1, 2};
        int target = 8;
        int index = Search(numbers, target);
        if (index != -1) {
            System.out.println("元素 " + target + " 的索引是 " + index);
        } else {
            System.out.println("未找到元素 " + target);
        }
    }
}

二分查找

        二分查找要求数组是有序的，它的效率比顺序查找高

import java.util.Arrays;

public class BinarySearchExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        int target = 3;
        int index = Arrays.binarySearch(numbers, target);
        if (index >= 0) {
            System.out.println("元素 " + target + " 的索引是 " + index);
        } else {
            System.out.println("未找到元素 " + target);
        }
    }
}

七、二维数组 

         二维数组可以看作是数组的数组，也就是每个元素又是一个数组。

int[][] c = {{1, 2},{3,4},{5,6},{8,9}};

        这个二维数组有 4 行 2 列，可将其想象成一个表格，每一行包含两个元素。

访问与遍历：

        访问元素：通过行索引和列索引来访问二维数组的元素。例如 c[3][0] 表示第 4 行（索引从 0 开始）的第 1 个元素，c[3][1] 表示第 4 行的第 2 个元素。

System.out.println(c[3][0]);
System.out.println(c[3][1]);

        遍历元素：通常使用嵌套的 for 循环来遍历二维数组的所有元素。外层循环控制行，内层循环控制列。

for (int i = 0; i < c.length; i++) {
    for (int j = 0; j < c[i].length; j++) {
        System.out.println(c[i][j]);
    }
}

封装方法打印一维数组

public static void printArray(int[] array){
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]+" ");
    }
}

封装方法打印二维数组

        // 打印二维数组的方法
        public static void print2rray(int[][] array) {
            // 遍历二维数组的每一行
            for (int i = 0; i < array.length; i++) {
                // 遍历当前行的每一个元素
                for (int j = 0; j < array[i].length; j++) {
                    // 打印当前元素，并在元素后面添加一个制表符 \t 以实现对齐
                    System.out.print(array[i][j] + "\t");
                }
                // 打印完一行后换行，以便下一行元素从新的一行开始显示
                System.out.println();
            }
        }

八、稀疏数组

基本概念

        当一个二维数组中大部分元素为 0 或者同一值时，使用稀疏数组可以有效减少存储空间和处理数据的规模。稀疏数组的处理方式是记录数组的行数、列数以及不同值的元素个数，然后把具有不同值的元素的行列及值记录在一个小规模数组中。

转换过程

        以 Sparse_Array 类为例，我们创建了一个 11x11 的二维数组 array01 来模拟棋盘，其中 0 表示没有棋子，1 表示黑棋，2 表示白棋：

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

        获取有效值个数：遍历二维数组，统计非零元素的个数。

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

        创建稀疏数组：稀疏数组的第一行记录原数组的行数、列数和有效值个数，后续每行记录一个有效值的行索引、列索引和值。

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

        存储有效值信息：再次遍历二维数组，将非零元素的信息存储到稀疏数组中。

int count =0;
for (int i = 0; i < array01.length; i++) {
    for (int j = 0; j < array01[i].length; j++) {
        if (array01[i][j]!=0){
            count++;
            array02[count][0] = i;
            array02[count][1] = j;
            array02[count][2] = array01[i][j];
        }
    }
}

还原过程

         创建二维数组：根据稀疏数组第一行的信息创建二维数组。

int[][] array03 =new int[array02[0][0]][array02[0][1]];

        还原元素值：遍历稀疏数组（从第二行开始），将元素值还原到二维数组的相应位置。

for (int i = 1; i < array02.length; i++) {
    array03[array02[i][0]][array02[i][1]] = array02[i][2];
}