Java基础：数组、稀疏数组

数组的定义

• 数组是同类型数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 其中的每一个数据乘坐一个数组元素，每个数组元素可以通过一个下标访问

数据声明创建

1. 声明数组变量

dataType[] arrayRefVar;	//首选方法
or
dataType arrayRefVar[];	//尽量不用，C语言中的方法

例：

//变量的类型 变量名 = 变量值；
int[] nums;		//1. 定义
or
int nums2[];	//2. C语言中的定义方法，少用

2. new操作符创建数组

dataType[] arrayRefVar = new dataType[arraySize];

例：

nums = new int[10];//可以存放10个int类型的数字

3. 赋值

数组的元素通过索引访问，数组索引从0开始

nums[0] = 1;

没有赋值时输出该类型数据的默认值

合并执行的方法：

int[] nums = {2,34,5,6};
或
int[] nums = new int[]{8,29,3,4};

获取数组长度

数组名.length

内存分析

• 堆：

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

• 栈：

  • 存放基本变量类型（会包含这个基本类型的具体数字）
  • 引用对象的变量（会存放这个引用在堆例的具体地址）

• 方法区

  • 可以被所有的线程共享
  • 包含了所有的class和static变量

1. 声明数组：在栈中创建空间
2. 创建数组：在堆中开辟空间
3. 赋值：在创建的数组中进行赋值

初始化方式

1. 静态初始化

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

类同样可以作为数组的元素（引用类型），如：

String[] humans = {new String(), new String()};

2. 动态初始化：包含默认初始化

int[] b = new int[10];
b[0] = 1;

3. 默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

在进行动态初始化时，在定义的数组空间中对元素进行了默认赋值，如int类型的默认值为0

数组的四个基本特点

• 长度确定，一旦确定数组大小无法改变
• 同一数组元素必须是相同类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属引用类型，数组也可以是做对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java的对象存放在堆中，数组无论保存原始类型还是其他对象类型，数组对象本身在堆中。

数组下标越界

数组下表超出设定的数量，超出空间。

下标合法区间为[0, length-1]，如果越界会报错

ArrayIndexOutOfBoundsException

总结

• 数组是相同数据类型（可为任意类型）的有序集合
• 数组也是对象，数组元素相当于对象的成员变量
• 数组长度是确定的、不可变的。若越界则报错。

数组的应用

arrays[i]，数组名[下标]选择数组中元素

• 普通for循环

• for each

数组名.for回车自动跳转至

for (int array : arrays) {
    
}

该方法没有下标

• 数组作方法如参
• 数组作返回值

多维数组

可视作数组的数组，每个元素都是一个一维数组

• 二维数组

int[][] array = {{1,2},{2,3},{3,4}};
System.out.println(array[0]); //输出数组的内存地址

• Arrays类中的方法都是static修饰的，使用时可以之间用类名调用，而不用使用对象来调用

Array类

• 修改成字符形式

Arrays.toString(a)

• 排序，升序

Arrays.sort(a);

• 数组填充

Arrays.fill(a,0);//修改所有元素为0
//在第2和4之间填充
Arrays.fill(a,2,4,0);//第3和4个元素修改为0

• 比较数组：使用equals方法比较数组中的元素是否相等
• 查找数组元素：通过binarySearch方法能对排序号的数组进行二分查找法操作。

冒牌排序

最出名的排序算法之一。

在两两之间进行比较，把较大的进行前移或后移，嵌套循环，时间复杂度为O(n2)

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] array = {3,54,6,2,7,4,5};
        int[] sort = sort(array);
        System.out.println(Arrays.toString(sort(array)));
    }
    //冒泡排序
    //1. 比较数组中两个相邻的元素，如果第一个数比第二个大，就交换他们的位置
    //2. 每次比较都会产生一个最大或最小的数字
    //3. 下一轮则可以少一次排序
    //4. 依次循环，直到结束

    public static int[] sort(int[] array){
        //外循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {
            //优化：通过flag表示为减少没有意义的比较
            boolean flag = false;

            //内层循环比较判别两个数，如果第一个数大，就交换他们的位置
            for (int j = 0; j < array.length-1; j++) {
                if(array[j]>array[j+1]){
                    int n = array[j];
                    array[j] = array[j+1];
                    array[j+1] = n;
                    flag = true; //如果在这一次循环中没有进行过数字交换，下一次循环就没有进行比较的意义，直接结束运行
                }
            }
            //在没有发生交换时跳出循环
            if(flag==false){
                break;
            }
        }
        return array;//可以不返回
    }
}

稀疏数组

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

处理方式为：

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

将二维矩阵转换为稀疏数组：

//创建一个数组
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;

//输出原始数组
for (int[] ints : array1) {
    for (int anInt : ints) {
        System.out.print(anInt + "\t");
    }
    System.out.println();
}

System.out.println("==============================");

//转换为稀疏数组保存
//计算有效值个数
//array1.length，行数，array1[0].length，列数
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++;
        }
    }
}
System.out.println("有效值的个数为："+sum);

//2. 创建一个系数数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = array1.length;
array2[0][1] = array1[0].length;
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];
        }
    }
}
System.out.println("稀疏矩阵为：");
for (int i = 0; i < array2.length; i++) {
    for (int j = 0; j < array2[0].length; j++) {
        System.out.print(array2[i][j]+"\t");
    }
    System.out.println();
}

输出结果为：

0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
==============================
有效值的个数为：2
稀疏矩阵为：
11	11	2	
1	2	1	
2	3	2	

将稀疏矩阵转换为数组

//1. 读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];

//2. 给其中的元素还原值
//创建时没命名的值默认是0
for (int i = 1; i < array2.length; i++) {
    array3[array2[i][0]][array2[i][1]]=array2[i][2];
}
for (int[] ints : array3) {
    for (int anInt : ints) {
        System.out.print(anInt + "\t");
    }
    System.out.println();
}

输出结果：

0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0