Java数组

什么是数组？

数组是相同类型数据的有序集合

数组中每个数据称为元素，每个元素可以通过一个下标来访问。数组下标从0开始

 

数组声明创建

1. 必须声明数组变量，才能在程序中使用数组

    dataType[] arrayRefVar;     //首选
    ​
    dataType arrayRefVar[];     //效果相同，但不是首选

2. Java语言使用new操作符来创建数组

    dataType[] arrayRefVar = new dataType[arraySize];

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

4. 获取数组长度：array.length

5. 三种初始化

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

      int[] nums = {1,2,3,4,5,6,7,8};

   • 动态初始化：包含默认初始化

      int[] nums = new int[10];
      nums[0] = 10;

   • 数组的默认初始化

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

6. 数组边界

   • 下标的合法区间[0，length-1]

   • ArrayIndexOutOfBoundsException：数组下标越界异常

 

数组使用

普通的for循环

for-each循环

数组作参数

数组作返回值

 

多维数组

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

二维数组

 int[][] a = new int[2][5];     //一个两行五列的数组

 

Arrays类

数组的工具类：java.util.Arrays

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用“使用对象来调用”（不用不是不能）

具有以下常用功能：

1. 给数组赋值：fill方法

2. 对数组排序：sort方法（升序）

3. 比较数组：equals方法比较数组中元素值是否相等

4. 查找数组元素：binarySearch方法对排序好的数组进行二分查找法操作

 

冒泡排序

冒泡的代码相当简单，两层循环，外层冒泡轮数，里层依次比较，时间复杂度为O(n^2)

 package array;
 ​
 import javax.sound.midi.Soundbank;
 import java.util.Arrays;
 ​
 public class Demo02 {
     public static void main(String[] args) {
         int[] a = {1,4,5,6,72,2,2,2,25,6,7};
         sort(a);
 ​
         System.out.println(Arrays.toString(a));
 ​
     }
 ​
     public static int[] sort(int[] array) {
         //外层循环
         for (int i = 0; i < array.length-1; i++) {
             //内层循环，比较相邻的两个数
             for (int j = 0; j < array.length-i-1; j++) {
                 if(array[j+1] > array[j]) {
                     int temp = array[j+1];
                     array[j+1] = array[j];
                     array[j] = temp;
                 }
             }
         }
 ​
         return array;
     }
 }

 

稀疏数组

当一个数组中大部分元素为0，或其他值，可使用稀疏数组来保存

处理方式是：

1. 记录数组一共几行几列，有多少个不同的值

2. 把具有不同值的元素的行和列及值记录在一个小规模数组中，从而缩小程序规模

如下：

$$\left( \begin{matrix} 0 & 0 & 0 & 22 & 0 & 0 & 15 \\ 0 & 11 & 0 & 0 & 0 & 17 & 0 \\ 0 & 0 & 0 & 6 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 39 & 0 \\ 91 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 28 & 0 & 0 & 0 & 0 \end{matrix} \right)$$

 

	行（row）	列（col）	值（val）
[0]	6	7	8
[1]	0	3	22
[2]	0	6	15
[3]	1	1	11
[4]	1	5	17
[5]	2	3	6
[6]	3	5	39
[7]	4	0	91
[8]	5	2	28

 package array;
 ​
 public class Demo03 {
     public static void main(String[] args) {
         //创建二维数组 11*11    0：没有棋子   1：黑子   2：白子
         int[][] array1 = new int[11][11];
         array1[1][2] = 1;
         array1[2][3] = 2;
 ​
         //输出原始的数组
         System.out.println("输出原始的数组");
         for (int[] ints:array1) {
             for (int num:ints) {
                 System.out.print(num+"\t");
             }
             System.out.println();
         }
         
         //转换为稀疏数组保存
         //获取有效值的个数
         int sum = 0;
         for (int i = 0; i < array1.length; i++) {
             for (int j = 0; j < array1[i].length; j++) {
                 if (array1[i][j] != 0) {
                     sum++;
                 }
             }
         }
 ​
         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[i].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[i].length; j++) {
                 System.out.print(array2[i][j]+"\t");
             }
             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[] ints:array3) {
             for (int num:ints) {
                 System.out.print(num+"\t");
             }
             System.out.println();
         }
     }
 }