【狂神说java笔记】数组

数组声明创建

两种方法：

1. int[] nums;
2. int nums[];
   使用new操作符来创建数组
   int[] nums = new int[10];
   获取数组长度：nums.length

数组特点

1. 长度固定，一旦定好，不可改变
2. 其元素必须是相同类型，不允许出现混合类型。
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组本身是对象，java的对象是在堆中的，使用new关键词创建的都在堆中。
5. 数组边界：合法区间：[0,length-1]，如果越界就会报错。

内存分析

声明的时候数组并不存在，使用new操作符创建后，数组才产生。

1. 静态初始化：int[] a = {1,2,3,4,5,6,7,8},创建+赋值一块做
2. 动态初始化：先创建（创建后所有元素默认为零），后赋值
3. 默认初始化：一经分配空间就默认值为零
   

数组使用

1. 增强for循环：如：
   for (int array :arrays){
   System.out.println(array)
   }
2. 数组可以作为参数导入方法，也可以作为返回值

多维数组

可以看为是一维数组的数组
定义：int[][] array = {{1,2},{3,4},{5,6},{7,8}}
横竖都是0-length-1

Arrays类

数组的工具类java.util.Arrays
可以按ctrl再点击进去看源码学习
Arrays.toString打印数组
Arrays.sort 排序
Arrays.fill 填充

冒泡排序

1. 比较数组中两个相邻的元素两数

• 排列符合顺序时，不动
• 不符合时，交换位置

2. 双层循环

• 外层循环判断比较的轮数
• 内层循环判断每轮比较的数的个数

3. 可以通过在外层循环增加flag变量来减少没有意义的比较

package array;

/**
 * @author soso
 * @PackageName:array
 * @ClassName:demo02
 * @Description:冒泡排序
 * @date 2024/8/2420:10
 */
public class demo02 {
    public static void main(String[] args) {
        int[] a = {1,3,2,9,345,654,443,256};
        printArray(sort(a));
    }
    public static int[] sort(int[] array) {
        int temp = 0;
        //判断走多少次
        for (int i = 0;i < array.length-1;i++){
            //设置flag变量判断此时顺序是否已经是最优
            boolean flag = false;
            //判断两个数的顺序，并决定是否交换位置
            for (int j = 0;j < array.length-i-1;j++){
                if (array[j] > array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
        }
        return array;
    }
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (i==0){
                System.out.print("["+array[i]);
            }else if (i==array.length-1){
                System.out.print(" "+array[i]+"]");
            }else{
                System.out.print(" "+array[i]);
            }
        }
    }
}

稀疏数组

当数组中大部分元素为零，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
处理方式：

• 记录数组的行数、列数和不同值的个数
• 把具有不同值的元素的行、列和值记录在一个小规模的数组中
  稀疏数组记录以及还原举例：

package array;

/**
 * @author soso
 * @PackageName:array
 * @ClassName:demo03
 * @Description:稀疏数组
 * @date 2024/8/2421:01
 */
public class demo03 {
    public static void main(String[] args) {
        //创建一个二维稀疏数组11*11
        int[][] array1 = new int[11][11];
        array1[0][0] = 1;
        array1[0][1] = 2;
        //输出原始数组
        System.out.println("输出原始数组：");
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                System.out.print(array1[i][j] + " ");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                if (array1[i][j] != 0) {
                    sum += 1;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

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

        //遍历二维数组，得到值的坐标并放于新的数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[0].length; j++) {
                System.out.print(array2[i][j] + " ");
            }
            System.out.println();
        }

        //将稀疏数组还原成原数组
        //读取稀疏数组的值
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //将还原的稀疏数组打印
        System.out.println("还原的数组：");
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3[0].length; j++) {
                System.out.print(array3[i][j] + " ");
            }
            System.out.println();
        }
    }
}

结果图：