数组详解-优快云博客

本文链接：https://blog.youkuaiyun.com/BHWTCL/article/details/115837201

数组

相同类型数据的有序集合
每一个数据为一个数组元素

声明与创建

首先必须声明数组变量，才能在程序中使用数组，声明数组变量的语法为：

int[] nums;//首选，java风格
int nums[];//效果相同，延续c，

创建数组

nums=new int[10];

给数组赋值

nums[0]=1;
```

可以把声明与创建数组整合在一起

int[] nums=new int[10];

内存分析

java内存

堆：存放new的对象和数组
栈：存放基本变量类型
方法区

数组的三种初始化

//静态初始化
int[] a={};
//动态初始化
int[] b=new int[10];
b[0]=1;
```
//

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，每个元素会默认给一个值，int类是0，字符类是null

数组的基本特点

长度确定，一旦创建，不能改变
元素是相同类型，不允许出现混合类型
数组的元素可以是任何数据类型，基本类型和引用类型
数组变量属于引用类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java的对象是在堆中的

数组边界

合法区间，从0开始数，int [10]里面最多到a[9]

ArrayIndexOutOfBounds 数组越界常见报错

数组使用

数组名+.length 直接出数组长度，可以在for循环中使用

反转数组

for(int i=0,j=arrays.length-1;i<arrays.length;i++,j--){
    result[j]=arrays[i];
}

多维数组

int[][] array=new int[2][5];
int[][] array2={{1,2},{2,3},{3,4},{4,6},{5,3}};
 int n=0;
        int[][] array=new int[2][4];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j]=n;
                n++;
                System.out.println(array[i][j]);
            }
        }

Arrays类

里面有很多工具，可以进行输出数组元素，Arrays.toString,或者对数组元素进行排序，Arrays.sort()

可以被static直接调用

冒泡排序

两层循环，外层冒泡轮数，里层依次比较
冒泡次数为数组元素个数-1
在第一轮的冒泡中，需要进行元素个数-1次比较
每进行一次冒泡，下一次的冒泡需要比较的元素个数-1
从小到大的排序是，将前面的大的数冒泡到后面，因此条件语句中，前一个数大于后一个数则更换顺序
从大到小的排序是，将前面小的数冒泡到后面，因此哦条件语句中，前一个数小于后一个数则更换顺序

嵌套循环的时间复杂度为O(n^2)

稀疏数组

当一个数组中大部分元素是0，或者同一值的数组时，可以用稀疏数组来保持该数组。如五子棋盘中，黑子1，白子2，无子0,0是占大多数位置的。
第一行记录数组几行几列几种元素
以后每行依次记录第几行，第几列，值

public class Demo06 {
    public static void main(String[] args) {
        int[][] x=new int[11][11];
        x[1][1]=1;
        x[2][2]=2;
        for (int[] ints : x) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");//输出一个棋盘
            }
            System.out.println();
        }
        int count=0;
        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x[i].length; j++) {
                if(x[i][j]!=0){
                    count++;
                }
            }
        }
        //创建稀疏数组
        int[][] y=new int[count+1][3];
        y[0][0]=11;
        y[0][1]=11;
        y[0][2]=count;
        int n=0;
            //将不为0的数读入稀疏数组中
        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x[i].length; j++) {
                if(x[i][j]!=0){
                    n++;
                    y[n][0]=i;
                    y[n][1]=j;
                    y[n][2]=x[i][j];
                }
            }
        }
        for (int i = 0; i < y.length; i++) {
            System.out.println(y[i][0]+" "+y[i][1]+" "+y[i][2]);//输出稀疏数组
        }
        //将稀疏数组转换成一般数组
        int[][] z=new int[y[0][0]][y[0][1]];
        //注意i=0时，是稀疏数组第一行，记录的是整体信息，因此i从1开始
        for (int i = 1; i < y.length; i++) {
            z[y[i][0]][y[i][1]]=y[i][2];
        }
        for (int[] ints : z) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }

    }
}