数组是多个相同类型数据的组合，实现对这些数据的统一管理
数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量

一维数组声明：
type  var[] 或 type[]  var；
例如：
           int a[];
           int[] a;
           double  b[];
           Mydate[] c;  //对象数组
数组初始化：

 1.动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行

//一维数组动态初始化
int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;
//一维对象数组动态初始化
MyDate dates[];
dates = new MyDate[4];
dates[0] = new MyDate(1990, 12, 12);
dates[1] = new MyDate(1991, 2, 12);
dates[2] = new MyDate(1999, 1, 14);
dates[3] = new MyDate(2000, 3, 5);

int[][] arrs;
//二维数组动态初始化一
arrs= new int[3][5];//3行5列
//二维数组动态初始化二
arrs= new int[3][];
//动态赋值
arrs[0] = new arrs[3];
arrs[1] = new arrs[2];
arrs[2] = new arrs[4];
arrs[1][0] = 12;

 2.静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

//一维数组静态初始化
int a[] = new int[]{ 3, 9, 8};
int[] a = {3,9,8};
//一维对象数组静态初始化
MyDate dates[] = {
    new MyDate(1990, 12, 12),
    new MyDate(1991, 2, 12),
    new MyDate(1999, 1, 14),
    new MyDate(2000, 3, 5)
}
// 二维数组静态初始化
int sources[][] = new int[][]{{1,2,3},{3,4,5},{6}};
i[1][0] = 90;
i[2][1] = 100;

 注：不管是动态还是静态初始化数组，一定在创建的时候，就指明了数组的长度！


数组元素的默认初始值：
 1)byte short int long 而言：0
 2)float double 而言：0.0
 3)char而言：空格
 4)boolean而言：false
 5)引用类型变量而言:null


数组的内存结构

一维数组的内存结构：

wKioL1kuaX6zKYwHAAEsInEqEpg387.png

二维数组内存结构:

wKioL1kui1XhUtlhAACu9rz9JFc620.png

数组遍历：

//一维数组遍历
for(int i = 0;i < arr.length;i++){
    System.out.println(scores1[i]);
}
//二维数组遍历
for(int m = 0;m < sources.length;m++){//控制行数
      for(int n = 0;n < sources[m].length;n++){
        System.out.print(names[m][n] + "  ");
      }
}

数组的常见异常：

//1.数组下标越界的异常:java.lang.ArrayIndexOutOfBoundsException
//数组的角标从0开始
int[] i = new int[10];
i[0] = 90;
i[10] = 99;     
for(int m = 0;m <= i.length;m++){
  System.out.println(i[m]);
}
//2.空指针的异常：NullPointerException
//第一种：
boolean[] b = new boolean[3];
b = null;
System.out.println(b[0]);
//第二种：
//String[] str = new String[4];
//str[3] = new String("AA");//str[3] = "AA";
//System.out.println(str[3].toString());
//第三种：
int[][] j = new int[3][];
j[2][0] = 12;

数组常见操作

1.冒泡排序

 相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其它的数进行类似操作。

// 使用冒泡排序使数组元素从小到大排列
for (int i = 0; i < arr.length - 1; i++) {
  for (int j = 0; j < arr.length - 1 - i; j++) {
     if (arr[j] > arr[j + 1]) {
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
     }
  }
}

2.直接排序

//使用直接选择排序使数组元素从小到大排列
for(int i = 0; i < arr.length - 1; i++){
  int t = i;//默认i处是最小的
  for(int j = i;j < arr.length;j++){
   //一旦在i后发现存在比其小的元素，就记录那个元素的下角标
   if(arr[t] > arr[j]){
      t = j;
   }
  }
  if(t != i){
     int temp = arr[t];
     arr[t] = arr[i];
     arr[i] = temp;
  }
}

3.折半查找（二分法）

/* 
    为了提高查找效率，可使用折半查找的方式，注意：这种查找只对有序的数组有效。 
    这种方式也成为二分查找法。 
    */  
    public static int halfSeach(int[] arr,int key)  
    {  
        int min,mid,max;  
        min = 0;  
        max = arr.length-1;  
        mid = (max+min)/2;  
  
        while(arr[mid]!=key)  
        {  
            if(key>arr[mid])  
                min = mid + 1;  
            else if(key<arr[mid])  
                max = mid - 1;  
              
            if(min>max)  
                return -1;  
      
            mid = (max+min)/2;  
        }  
        return mid;  
    }

4.数组翻转

/* 
    反转其实就是头角标和尾角标的元素进行位置的置换， 
    然后在让头角标自增。尾角标自减。 
    当头角标<尾角标时，可以进行置换的动作。 
    */  
    public static void reverseArray(int[] arr)  
    {  
        for(int start=0,end=arr.length-1; start<end; start++,end--)  
        {  
            swap(arr,start,end);  
        }  
    }  
    //对数组的元素进行位置的置换。  
    public static void swap(int[] arr,int a,int b)  
    {  
        int temp = arr[a];  
        arr[a] = arr[b];  
        arr[b] = temp;  
    }