Java数组扩展

目录

一、多维数组（以二维数组为例）

多维数组的动态初始化

多维数组的引用

二、Arrays类

三、冒泡排序

四、稀疏数组

---

一、多维数组（以二维数组为例）

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

 String str[][] = new String[3][4];

多维数组的动态初始化

1、直接为每一维分配空间

格式如下：

 type[][] typeName = new type[typeLength1][typeLength2];

 int[][] a = new int[2][3];

解析：二维数组 a 可以看成一个两行三列的数组。

• type 可以为基本数据类型和复合数据类型

• typeLength1 和 typeLength2 必须为正整数

• typeLength1 为行数，typeLength2 为列数

2、从最高维开始，分别为每一维分配空间

例如：

 String[][] s = new String[2][];
 s[0] = new String[2];
 s[1] = new String[3];
 s[0][0] = new String("Good");
 s[0][1] = new String("Luck");
 s[1][0] = new String("to");
 s[1][1] = new String("you");
 s[1][2] = new String("!");

解析：

• s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度

• 然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。

多维数组的引用

对二维数组中的每个元素,引用方式为

  arrayName[index1][index2];

 num[1][0];

二、Arrays类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

功能

• 给数组赋值：通过 fill 方法。

• 对数组排序：通过 sort 方法,按升序。

• 比较数组：通过 equals 方法比较数组中元素值是否相等。

• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表：

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

三、冒泡排序

1、原理

1、从第一个数据开始，与第二个数据相比较，如果第二个数据小于第一个数据，则交换两个数据的位置。

2、指针由第一个数据移向第二个数据，第二个数据与第三个数据相比较，如果第三个数据小于第二个数据，则交换两个数据的位置。

3、依此类推，完成第一轮排序。第一轮排序结束后，最大的元素被移到了最右面。

4、依照上面的过程进行第二轮排序，将第二大的排在倒数第二的位置。

5、重复上述过程，没排完一轮，比较次数就减少一次。

2、例子

待排序数据：7, 6, 9, 8, 5,1

第一轮排序过程：

 指针先指向7，7和6比较，6<7，交换6和7的位置，结果为：6,7,9,8,5,1
 指针指向第二个元素7，7和9比较，9>7，不用交换位置，结果仍为：6,7,9,8,5,1
 指针指向第三个元素9，比较9和8，8<9，交换8和9的位置，结果为：6,7,8,9,5,1
 指针指向第四个元素9，比较9和5，5<9，交换5和9，结果为：6,7,8,5,9,1
 指针指向第五个元素9，比较9和1，1<9，交换1和9的位置，结果为6,7,8,5,1,9

第一轮排序结束后，最大的数字9被移到了最右边。

进行第二轮排序，过程同上，只是由于最大的9已经放在最右边了，因此不用在比较9了，少了一次比较，第二轮结束的结果为：6,7,5,1,8,9

第三轮结果：6,5,1,7,8,9

第四轮比较结果：5,1,6,7,8,9

第五轮比较结果：1,5,6,7,8,9

最终排序结果为：1,5,6,7,8,9

由上可知N个数据排序，需要进行N-1轮排序；第i轮排序需要的比较次数为N-i次。

3、编码思路

需要两层循环，第一层循环i表示排序的轮数，第二层循环j表示比较的次数。

我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为0(n2)。

4、代码实现

 public class ArrayDemo09 {
     public static void main(String[] args) {
         int[] a = {12, 14, 34, 32, 15};
         int[] sort = sort(a);
         System.out.println(Arrays.toString(sort));
     }
 ​
     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 - 1 - i; j++) {
                 if (array[j + 1] > array[j]) {
                     temp = array[j];
                     array[j] = array[j + 1];
                     array[j + 1] = temp;
                     flag = true;
                 }
             }
             //冒泡排序优化
             if (flag == false) {
                 //没有进行比较，跳出循环，降低时间成本
                 break;
             }
         }
         return array;
     }
     //i=0 j<4           i=1 j<3        i=2 j<2        i=3 j<1
     //14,34,32,15,12    34,32,15,14
 ​
     /*冒泡排序
      1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
      2.每一次比较，都会产生出一个最大， 或者最小的数字;
      3.下一轮则可以少一次排序!
      4.依次衙环，直到结束!
      */
 }
 ​

四、稀疏数组

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

处理方式：

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

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