多层数组如何遍历_带你从零学大数据系列之Java篇---第五章：数组

温馨提示:如果想学扎实,一定要从头开始看凯哥的一系列文章(凯哥带你从零学大数据系列),千万不要从中间的某个部分开始看,知识前后是有很大关联,否则学习效果会打折扣.

系列文章第一篇是拥抱大数据：凯哥带你从零学大数据系列-学习大数据前奏(必读)(点我)!

上一篇:拥抱大数据：凯哥带你从零学大数据系列之Java篇---第四章:方法

课程重点：

数组的声明与实例化
数组的引用
数组的元素访问
数组的排序
数组的查询
Arrays工具类

5.1. 数组的概念

5.1.1. 一个案例

如何存储100名学生的成绩
- 办法：使用变量存储，重复声明100个double类型的变量即可。
- 缺点：麻烦，重复操作过多。

如何让100名学生成绩全部+1
- 办法：100个变量重复相同操作，直到全部完毕。
- 缺点：无法进行统一的操作。

5.1.2. 数组是什么

数组，是一个数据容器。可以存储若干个相兼容的数据类型的数据。

在上述案例中，存储100名学生的成绩，可以用数组来完成。将这100个成绩存入一个数组中。此时对这些数据进行统一操作的时候，直接遍历数组即可完成。

5.1.3. 数组的特点

数组中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。
数组的长度是不可变的。一个数组一旦实例化完成，长度不能改变。

5.2. 数组的声明

5.2.1. 声明数组

/*** @Description 数组的声明*/public class Test{   public static void main (String[] args) {       // 声明一个数组， 存储若干个double类型的数据       double[]  array1;       // 声明一个数组， 存储若干个int类型的数据       int[]  array2;       // 声明一个数组， 存储若干个String类型的数据       String[]  array3;  }}

5.2.2. 数组的实例化

实例化数组：其实就是在内存中开辟空间，用来存储数据。

/*** @Description 数组的声明*/public class Test {   public static void main (String[] args) {       // 实例化了一个数组， 可以存储5个数据       // 此时数组中的元素就是默认的5个0       int[] array1=new int[5];       // 实例化了一个数组， 默认存储的是 1, 2, 3, 4, 5       // 此时数组的长度， 由这些存储的数据的数量可以推算出来为5       int[] array2=new int[] { 1, 2, 3, 4, 5};       // 实例化了一个数组， 默认存储的是 1， 2， 3， 4， 5       // 相比较于第二种写法， 省略掉了 new int[]       int[] array3={ 1, 2, 3, 4, 5};  }}

5.2.3. 数组引用

数组的实例化的时候，需要使用到关键字new

以后但凡是遇到了new, 都表示在堆上开辟空间！

数组，其实是在堆上开辟的连续的空间。例如 new int[5] ，就是在堆上开辟5个连续的4字节空间。

然后，将堆上的内存地址，给栈上的引用进行赋值。

5.3. 数组的下标

5.3.1. 下标的概念

下标，就是数组中的元素在数组中存储的位置索引。

注意：数组的下标是从0开始的，即数组中的元素下标范围是 [0, 数组.length - 1)

5.3.2. 访问数组元素

访问数组中的元素，需要使用下标访问。

/*** @Description 数组的元素访问*/public class Test {   public static void main (String[] args) {       // 实例化一个数组       int[]  array={ 1, 2, 3, 4, 5};       // 访问数组中的元素       array[2] = 300; // 将数组中的第2个元素修改成300， 此时数组中的元素是 [ 1, 2, 300, 4, 5 ]       System.out.println (array[2]);// 获取数组中的第2个元素， 此时的输出结果是 300  }}

5.3.3. 注意事项

在访问数组中的元素的时候，注意下标的问题！

如果使用错误的下标访问数组中的元素，将会出现 ArrayIndexOutOfBoundsException 异常！

/*** @Description 数组的元素访问*/public class Test {   public static void main (String[] args) {       // 实例化一个数组       int[] array = { 1, 2, 3, 4, 5};       // 访问数组中的元素       array[10] = 300;// 使用下标10访问数组中的元素， 此时数组的最大下标为4， 就会出现 ArrayIndexOutOfBoundsException 异常   }}

5.4. 数组的遍历

数组遍历：其实就是按照数组中元素存储的顺序，依次获取到数组中的每一个元素。

5.4.1. 下标遍历

思路：循环依次获取数组中的每一个下标，再使用下标访问数组中的元素

/*** @Description 下标遍历*/public class Test {   public static void main (String[] args) {       // 实例化一个数组       int[] array={ 1, 2, 3, 4, 5};       // 使用下标遍历数组       for(int i=0; i

5.4.2. 增强for循环

思路：依次使用数组中的每一个元素，给迭代变量进行赋值。

/*** @Description 下标遍历*/public class Test {   public static void main (String[] args) {       // 实例化一个数组       int[] array={ 1, 2, 3, 4, 5};       // 依次使用数组中的每一个元素， 给迭代变量进行赋值。       // 此时， 数组中的每一个元素依次给 element 进行赋值。       for(int element: array) {           System.out.println (element);      }  }}

5.4.3. 两种方式的对比

如果需要在遍历的同时，获取到数组中的元素下标，需要使用下标遍历法。
如果需要在遍历的同时，修改数组中的元素，需要使用下标遍历法。
如果仅仅是想要获取数组中的每一个元素，不需要下标，也不需要修改数组中的元素，使用增强for循环。因为这种方式，遍历的效率比下标遍历法高。

5.5. 数组的排序

排序，即排列顺序，将数组中的元素按照一定的大小关系进行重新排列。

在Java中，常见的排序有:

选择排序：固定值与其他值依次比较大小，互换位置。
冒泡排序：相邻的两个数值比较大小，互换位置。JDK排序：java.util.Arrays.sort(数组); // JDK提供默认的升序排序

5.5.1. 选择排序

/*** @Description 选择排序*/public class Test {   public static void main (String[] args) {       // 实例化一个数组       int[] array={ 1, 2, 3, 4, 5};       // 选择排序       sort (array);  }   /**    * 使用选择排序，对数组进行排列    * @param array 需要排序的数组    */   public static void sort (int[] array) {       int times=0;       // 1. 固定下标，和后面的元素进行比较       for(int i=0; i

5.5.2. 冒泡排序

/*** @Description 冒泡排序*/public class Test {   public static void main (String[] args) {       // 实例化一个数组       int[] array={ 1, 2, 3, 4, 5};       // 冒泡排序       sort (array);  }   /**    * 使用冒泡排序进行升序排序    * @param array 需要排序的数组    */   public static void sort (int[] array) {       // 1. 确定要进行多少趟的比较       for(int i=0; iarray[j+1]) {                   int temp = array[j];                   array[j] = array[j+1];                   array[j+1] = temp;              }          }      }  }}

5.6. 数组的查询

数组查询，即查询数组中的元素出现的下标。

5.6.1. 顺序查询

顺序查询，即遍历数组中的每一个元素，和要查询的元素进行对比。如果是要查询的元素，这个下标就是要查询的下标。

/*** @Description 顺序查询*/public class Test {   public static void main (String[] args) {       // 1. 实例化一个数组       int[] array={ 1, 3, 5, 7, 9, 0, 8, 8, 8, 6, 4, 8,  2};       // 2. 从这个数组中查询元素8的下标       System.out.println (indexOf (array, 80));  }   /**    * 使用顺序查询法，从数组array中查询指定的元素    * @param array 需要查询的数组    * @param element 需要查询的元素    * @return 下标    */   public static int indexOf (int[] array, int element) {       // 1. 使用下标遍历法，依次获取数组中的每一个元素       for(int i=0; i

5.6.2. 二分查询

二分查询，即利用数组中间的位置，将数组分为前后两个字表。如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

二分查询，要求数组必须是排序的，否则无法使用二分查询。

/*** @Description 二分查询*/public class Test {   public static void main (String[] args) {       int[] array = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19};       System.out.println (binarySearch (array, 14));  }   /**    * 二分查询，查询数组中element出现的下标    * @param array 需要查询的数组    * @param element 需要查询的元素    * @return 元素出现的下标，如果数组中不包含这个元素，返回-1    */   public static int binarySearch (int[] array, int element) {       // 1. 定义两个变量，用来标记需要查询范围的上限和下限       int max = array.length-1, min=0;       while(max>=min) {           // 2. 计算中间下标           int mid = (max+min) /2;           // 3. 使用中间下标的元素和要查询的元素进行比较           if(array[mid] == element) {               // 说明找到了               return mid;          }           elseif (array[mid] >element) {               // 中间位比要查询的元素大               max = mid-1;          }           else{               // 中间位比要查询的元素小               min = mid+1;          }      }       // 如果循环走完了，依然没有结果返回，说明要查询的元素在数组中不存在       return -1;  }}

5.7. 可变长参数

5.7.1. 概念

可以接收多个类型相同的实参，个数不限，使用方式与数组相同。

在调用方法的时候，实参的数量可以写任意多个。

5.7.2. 语法

数据类型... 形参名 (必须放到形参列表的最后位，且只能有一个)

// 这里的参数paramters其实就是一个数组static void show (int...  parameters) {//    }

5.7.3. 使用

/*** @Description 不定长的参数案例*/public class Test {   public static void main (String[] args) {       // int[] array = { 1, 2, 3 };       // showArray(array);       // 如果一个方法的参数，使用 ... 来定义，可以将这个数组中的元素，直接写到实参列表中       // 注意事项:       // 1. 在形参列表中，可变长度的参数，必须在形参列表的最后位       // 2. 一个形参列表中，只能存在一个...修饰的可变长度参数       showArray (1, 2, 3, 4, 5, 6, 7, 8, 9, 0);  }   /**    * 对数组array进行遍历    * @param array    */   public static void showArray (int a, int...  array) {       for(int i : array) {           System.out.print (i+", ");      }  }}

5.8. 二维数组

5.8.1. 概念

二维数组，其实就是数组中嵌套数组。

二维数组中的每一个元素都是一个小的数组。

理论上来讲，还可以有三维数组、四维数组，但是常用的其实就是二维数组。

5.8.2. 定义与使用

/*** @Description 二维数组的定义与使用*/public class Array3 {   public static void main (String[] args) {       // 1. 实例化一个二维数组       //   第一个中括号中的3: 二维数组中包含了三个一维数组       //   第二个中括号中的5: 二维数组中的每一个一维数组长度为5       int[][] array = new int[3][5];       // 使用双下标访问数组中的元素       array[0][3] = 10;       // 这里得到的，是二维数组的长度，3       System.out.println (array.length);       // 2. 实例化一个二维数组       //   第一个中括号中的3: 二维数组中包含了三个一维数组       //   第二个中括号中什么都没有，代表现在二维数组中的三个元素是 null       int[][] array2 = new int[3][];       array2[0] = new int[] { 1, 2, 3};       // 3. 通过初始值实例化一个二维数组       int[][] array3 = { {1, 2, 3}, {1, 2, 3, 4, 5}, {2, 3, 4} };  }}

5.9. Arrays工具类

5.9.1. 常用方法

5.9.2. 示例代码

/*** @Description 二维数组的定义与使用*/public class ArraysUsage {   // Arrays 工具方法: 可以便捷的实现指定操作的方法   // Arrays 工具类: 若干个工具方法的集合   public static void main (String[] args) {       // 1. 实例化一个数组       int[] array = { 1, 3, 5, 7, 9, 0, 8, 6, 4, 2};       // 从原数组中拷贝指定数量的元素，到一个新的数组中，并返回这个新的数组       // 第一个参数：源数组       // 第二个参数：需要拷贝的元素数量，如果这个数量比源数组长，目标数组剩余的部分补默认值       int[] ret1 = Arrays.copyOf (array, 13);       // 从原数组中拷贝指定范围 [from, to) 的元素，到一个新的数组中，并返回这个新的数组       // 第一个参数：源数组       // 第二个参数：起始下标，从这个下标位的元素开始拷贝       // 第三个参数：目标下标，拷贝到这个下标位截止       int[] ret2 = Arrays.copyOfRange (array, array.length, array.length+10);       // 判断两个数组是否相同       // 判断的逻辑：长度、每一个元素依次都相等       boolean ret3 = Arrays.equals (ret1, ret2);       // 使用指定的数据，填充数组       // 第一个参数：需要填充的数组       // 第二个参数：填充的数据       Arrays.fill (ret2, 100);       // 对数组进行排序(升序)       Arrays.sort (array);       // 使用二分查找法，到数组中查询指定的元素出现的下标       // 第一个参数：需要查询的数组       // 第二个参数：需要查询的数据       // 返回：这个元素出现的下标，如果不存在，返回-1       int index = Arrays.binarySearch (array, 4);       // 将数组中的元素拼接成字符串返回       String str = Arrays.toString (array);       System.out.println (str);  }}