目录
1：空指针异常， 当一个数组对象为null是，还进行调用方法和数字属性，
2：数组越界异常（ArrayOutIndexOfBoundException）
一：创建数组(int a[]=new int[5];)
1：声明数组（定义数组有两种方式）
type [] arr_name;//推荐使用
type arr_name [];//c#中不支持
————注意：（1）声明数组不可指定长度，即int [5] a;这种做法是错的，仅仅是声明数组是不可指定长度。
2：创建数组（两种方法，通过new标识符创建数组对象）
（1） int arr_name;
arr_name=new int[10];//注：数组下标是从0到9。先声明在数组，在创建数组
（2） int [] args=new int[5];//声明的同时创建数组,两种效果一样的。
3：初始化数组（初始化数组有两种方式）
静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
程序员无需指定数组长度，指定该数组的元素即可，由系统自动复制
int [] arr; //只是在main方法中定义了一个arr数组变量，并未指向任何有效内存，只用一个栈 内存没有堆内存，所以声明的时候只声明了栈。
arr=new int[]{1,3,2,4,5};//分配了堆内存，即有了有效内存，数组所占的空间也被定了下来，堆内存中的对象 不 可以被直接访问，只能通过引用变量访问堆内存中的对象。
动态初始化：数组定义与为数组元素分配空间和赋值操作分开进行。
int [] a;
a=new int [3];
a[0]=1;a[1]=2;a[2]=3;//若不赋值，默认为0；
程序员只需指定数组的长度，即为每个数组元素指定所需的内存空间，系统将
为这些数组元素赋值。
//系统赋值的规则
byte, short, int, long类型的系统赋初值为0
float, double 类型的系统赋初值为0.0
char类型的系统赋初值为'\u0000'
引用类型（类，接口，数组）系统赋初值null
注意：Java数组是静态的，一旦为数组初始化完成，数组元素的内存分配空间即结束，
程序只能改变数组元素的值无法改变数组的长度。
4：访问数组
通过数组下标访问数组，a[0]访问的是数组中的第一个元素；
5：数组长度（ 如何得到数组的长度）
length属性（全局变量），a.length的值为数组的长度，System.out.println(a.length);直接输出数组的长度
a.length不是length()方法；
如果要得到String类型的长度，需要用到其他的length()方法
二：数组排序
1：选择排序
public class SelectSort
{
private int [] a={12,3,23,34,16,11};
public void selectSort()
{
System.out.println("开始排序");
int arrayLength = a.length;
for (int i = 0; i < arrayLength - 1 ; i++ )
{
int minIndex = i ;
for (int j = i + 1 ; j < arrayLength ; j++ )
{
if (a[i]-(a[j]) > 0)
{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
System.out.println(java.util.Arrays.toString(a));
}
}
public static void main(String[] args)
{
SelectSort s=new SelectSort();
System.out.println("排序之前：\n"
+ java.util.Arrays.toString(s.a));
s.selectSort();
System.out.println("排序之后：\n"
+ java.util.Arrays.toString(s.a));
}
}2：冒泡排序
public static void bubbleSort(int [] a){
for(int i=0;i<a.length-1;i++){
for(int j=0;j<a.length-1-i;j++){
int tmp=0;
if(a[j]-a[j+1]>0){
tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
}
}3：快速排序
public class A {
public static void main(String[] args){
int [] a={8,7,5,2,3,6};
quickSort(a,0,a.length-1);
for(int k:a){
System.out.println(k);
}
}
public static void quickSort(int [] a,int start,int end){
int i=start;
int j=end;
boolean flag=true;
if(i>=j){
return;
}
while(i!=j){
if(a[i]>a[j]){
int t=0;
t=a[i];
a[i]=a[j];
a[j]=t;
flag=!flag;
}
if(flag){
j--;
}else{
i++;
}
}
i--;
j++;
quickSort(a,start,i);
quickSort(a,j,end);
}
}三：遍历数组
1：for循环遍历数组
int[] a=new int[100];
for(int i=0;i<100;i++){
a[i]=i;
System.out.println(a[i]);
}2：for each 遍历数组
int[] a=new int[]{1,2,3,4,5,6,7};
for (int i : a) {
System.out.println(i);
}四：典型的数组处理
1：复制数组
把一个数组的值，复制到另一个数组中
private static void copyArray(){
int a[]={2,3,4,5,1,90,12};
int n=a.length;
double[] b=new double[n];
for(int i=0;i<n;i++){
b[i]=a[i];
}
for(double i :b){
System.out.println(i);
}
}
2：找出数组中最大的元素
public class Max {
public static void main(String[] args){
int [] a={1,3,56,23,2,5};
int tem=a[0];
for(int i=0;i<a.length;i++){
if(a[i]>tem)
tem=a[i];
}
System.out.println(tem);
}
}3：计算数组元素的平均值
public class Average {
public static void main(String[] args){
int [] a={1,2,3,4};
double sum=0.0;
for(int i=0;i<a.length;i++){
sum=sum+a[i];
}
System.out.println(sum/a.length);
}
}4：颠倒数组元素的顺序
private static void reversalArray(){
double a[]={2,3,4,5,1,90};
int n=a.length;
for(int i=0;i<n/2;i++ ){
double temp=a[i];
a[i]=a[n-1-i];
a[n-1-i]=temp;
}
for(double i :a){
System.out.println(i);
}
}5：二分查找法//折半查找
（1）优缺点：①优点：比较次数少，查找速度快，平均性能好。
②缺点：要求待查表为有序表，且插入删除困难
（2）适用于：适用于不经常变动而查找频繁的有序列表。//!!!所以二分查找之前一定要排序。
（3）时间复杂度：O(log2 n)
（4）算法原理：当有一连串数字（1,2,3,4,7,8,9,6,5）时，//先将无序数组进行排序，在二分（1,2,3,4,5,,6,7,8,9）
确立关键字key（你要查找的值，比如你要找到数字6，那么6就是你的关键字），
算法中使用了lo和hi两个变量，将0设置为lo,arr.length-1设置为hi,
索引叫mid，即mid=(lo+hi)/2,将key与arr[mid]进行比较
当key小于中间值arr[mid],说明key在lo和arr[mid]中间，这时将hi向中间值的左端移动，即hi=mid-1。
当key大于中间值arr[mid],说明key在hi和arr[mid]中间，这时将lo向中间值的右端移动，即lo=mid+1。
否则返回mid。
重复比较arr[mid]的值与key的值，直到找到key为止
（5）实现：①JDK方法实现：
②手动二分查找：//查找之前一定要排序！！！（多提了几次）
public class Abinary {
public static void main(String args[]){
//erfen
int []a={2,1,3,4,5};
Arrays.sort(a);
System.out.println(Arrays.binarySearch(a,1));
System.out.println(binarySearch(1,a));
}
public static int binarySearch(int key,int a[]){
int low = 0;
int high = a.length-1;
while(low<=high){
int mid=(low+high)/2;
if(key<a[mid]){
high=mid-1;
}else if(key>a[mid]){
low=mid+1;
}else{
return mid;
}
}
return -1;
}
}
五：二维及多维数组
1：初始化二维数组(数组的数组，Java中没有真正的数组)
格式：数组类型[][] 数组名称=new 数组类型[第一维长度 行][第二维长度 列];
（1）int [] [] a=new int [2][3];
（2）int [] [] b=new int [2][];
b[0]=new int [5];
b[1]=new int [3];