数组（Array）是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。

                                                                                                                                ---------------  百科

概述：数组是具有相同数据类型的一组数据集合。
如果一维数组中的各个元素仍然是一个数组，那么他就是一个二维数组。二维数组常用于表示表，表中的信息以行和列的形式组织，第一个下标表示所在行，第二个下标表示元素所在列。

声明：

• 一维
  • 数组元素类型 数组名字[];
  • 数组元素类型[] 数组名字; （推荐）
• 二维
  • 数组元素的类型 数组名字[][];
  • 数组元素的类型[][] 数组名字;（推荐）

初始化：

• 一维
  • 数组元素类型[] 数组名字 = new 数组元素的类型[数组元素的个数];
  • 数组元素类型[] 数组名字 = new 数组元素的类型[]{值1,值2,...,值n};
  • 数组元素类型[] 数组名字 = {值1,值2,...,值n};
• 二维
  • 先new运算符进行分配，在分别为每一维数组分配内存
    
         int marray[][] = new int[2][4];
         marray[0] = new int[4];
         marray[1] = new int[4];
  • 声明同时为数组分配内存
    
         int marray[][] = {value1,value2,...,value};

数组常用的操作

• 数组的长度
  • 数组有length属性，数组名.length即为数组数组长度
• 填充替换数组元素（仅以 int 类型说明）
  
         Arrays.fill(int a[], int value)
         Arrays.fill(int a[], int fromIndex, int toIndex, int value)
  
         a[]：要进行填充的数组
         fromIndex：要使用指定值填充的第一个元素的索引（包括第一个元素）
         toIndex：要是有指定值填充的最后一个元素的索引（不包括最后一个元素）
         value：要存储在数组所有元素中的值
• 数组排序
  • 通过 Arrays 的 sort() 方法可以实现数组排序，有多种重载方式
• 复制数组

               Arrays 的 copyOf() 方法和 copyOfRange() 方法可以实现对数组的复制。
               copyOf() 方法是复制数组至指定长度
               copyOfRange() 方法则是将指定数组的指定长度复制到一个新数组中

               Arrays.copyOf(arr[], int newLength)
               Arrays.copyOfRange(arr[], int fromIndex, int toIndex)

               arr[]：要进行复制的数组对象
               newLength：复制后的新数组长度。如果新数组长度大于数组arr的长度，新位置用                                       0填充。如果复制后的数组长度小于数组arr的长度，则会在数组arr的                                       第一个元素开始截取至满足新数组长度为止
               fromIndex：开始复制数组的索引位置。必须0至整个数组的长度区间，新数组包括                                     索引是fromIndex的元素
                toIndex：复制范围的最后索引位置。可大于arr[]的长度范围，新数组不包括索引                                        是toIndex的元素

• 数组查询
  
  Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值
  
  binarySearch(Object[] arr, Object key)
  binarySearch(Object[] arr, int fromIndex, int toIndex, Object key)
  
  arr[]：要搜索的数组
  key：要搜索的值
  fromInde：指定范围的开始处索引
  toIndex：指定范围内结束出索引
  
  返回值说明：
  
          1、如果找到关键字，则返回值为关键字在数组中的位置索引，且索引从0开始
          2、如果没有找到关键字，返回值为负的插入点值，所谓插入点值就是第一个比关                   键字大的元素在数组中的位置索引，而且这个位置索引从1开始
  注意：调用binarySearch()方法前要先调用sort方法对数组进行排序，否则得出的返回值不定，这是二分搜索算法决定的

 数组排序算法

        数组的排序有：冒泡排序、直接选则排序、反转排序

冒泡排序：对比相邻的元素值，如果满足条件就交换元素值，把小的元素移到数组前面，把大的元素移到数组后面（也就是两个元素互换位置），这样小的元素就像气泡一样从底部上升到顶部。

实现方式：冒泡排序由双层循环实现，其中外层循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要进行对比同时数组已经进行完排序了。而内循环主要用于对比数组中每个临近元素的大小，以确定是否交换位置，对比和交换次数随配许轮数减少而减少。

int[] arr = {65,23,1,2,5,3,9};
 
for(int i = 1; i < arr.length; i++){
    for(int j = 0; j < arr.length-i; j++){
        if(arr[j] > arr[j+1]){
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

直接选择排序：是选择排序的一种，排序速度要比冒泡排序快一些。

实现方式：将指定排序位置与其他数组元素分别对比，如果满足条件就进行元素交换，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定元素位置交换。就是说，每一趟从待排序的数据元素中选出最小（最大）的元素，顺序放在待排序的数列最前，直到全部待排序的数据元素全部排完。与冒泡排序相比，直接选中排序的交换次数要少，所以速度更快。

int[] arr = {63,4,24,1,3,5,2};
 
for(int i = 1; i <arr.length; i++){
    int index = 0;
    for(int j = 1; j <= arr.length - i; j++){
        if(arr[j] > arr[index]){
            index = j;
        }
    }
 
    int temp = arr[arr.length - i];
    arr[arr.length - i] = arr[index];
    arr[index] = temp;
}

反转排序：以相反的顺序把原有的数组的内容重新排序。

实现方式：就是把数组最后一个元素与第一个元素替换，到数第二个元素与第二个元素替换，依此类推。在循环时，只需要循环数组长度的半数。

int arr = {10, 20, 30, 40, 50, 60};
 
for(int i = 0; i < arr.length/2 -1; i++){
    int temp = arr[i];
    arr[i] = arr[arr.length - i];
    arr[arr.length - i] = temp;
}