带你从零学大数据系列之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<array.length; i++) {
           System.out.println (array[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<array.length-1; i++) {
           // 2. 定义一个变量，用来记录最小值的下标
           int minIndex = i;
           // 3. 找出剩余元素中的最小值
           for(int j=i+1; j<array.length; j++) {
               if(array[j] <array[minIndex]) {
                   minIndex = j;
              }
          }
           // 4. 交换第i位和最小值位的元素即可
           if(minIndex != i) {
               int temp = array[i];
               array[i] = array[minIndex];
               array[minIndex] = temp;
               times++;
          }
      }
       System.out.println (times);
  }
}

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; i<array.length-1; i++) {
           // 2. 每趟比较，从第0位开始，依次比较两个相邻的元素
           for(int j=0; j<array.length-1-i; j++) {
               // 3. 比较两个相邻的元素
               if(array[j] >array[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<array.length; i++) {
           // 2. 依次用每一个元素和element进行比较
           if(array[i] == element) {
               // 说明找到了这个元素，这个下标就是想要的下标
               return i;
          }
      }
       // 约定俗成：如果要查询的元素，在数组中不存在，一般情况下，得到的结果都是-1
       return -1;
  }
}

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);
  }
}