Java中数组的定义与使用（详解）

1、数组：是引用数据类型。
1）数组赋值：int[] a={1,2,3,4};
2）数组动态初始化（声明并开辟数组）：eg:int[]a=new int[5];//若这个数组元素没有数组化，这个数组中默认值为0（根据元素类型来选择 例如 double类型就是0.0 int类型就是0）
数组的访问通过索引完成。如果访问超过索引访问，那么产生⽣"java.lang.ArrayIndexOutOfBoundsException"异常信息。
3）数组属于引用类型 因此在使用之前一定要开辟空间（实例化）
数组存放在堆内存中 数组属性存放在栈内存中
引用变量（存放在哪里不确定）：
形参 栈
局部变量 栈
属性 堆
静态属性 方法区
java内存中有三个区域：栈去 堆区 方法区 （引用有可能在栈区 有可能在堆区）
以后使⽤静态⽅式定义数组的时候，请使⽤完整格式。
2、引用传递（java都是值传递，所有形参的改变都不会影响实参）：引用的方法调用也是值传递 形参的改变不会影响实参
引用是用来找到实际对象的线索​
1)引用类型是个线索，用来找到堆中真正的数据
2）引用类型也是值传递，形参的改变不会影响实参
关于数组的练习（理解引用传递）

public static void method(int[]a){
    a=new int[]{10,11,,12,13,14};
}
public static void method2(int []b){
      b[0]=19;
}
public static void main (String[]args){
        int[]a={4.5.6.7.8};
        method(a); 结果a数组还是原来的值 []a={4,5,6,7};
        int[] b={1,2,3,4,5};
        method(b); 结果[]b={10,2,3,4,5};
}

3.练习数组练习题：
（1）.二分查找

//方法1：[left,right)
public static int binarySearch(int[]a,int v){
        int left=0;
        int right=a.length;
        while(left<right){
        int mid=(right+left)/2;
        if(a[mid]==v){
            retrun mid;
           }
       else if(v>a[mid]){
            left=mid+1;
          } else{
           right=mid;
           }      
   }
return -1;
}
//方法二：[left,right]
public static int binarySearch2(int[]a,int v){
        int left=0;
        int right=a.length-1;
        while(left<=right){
        int mid=(right+left)/2;
        if(a[mid]==v){
            retrun mid;
           }
       else if(v>a[mid]){
            left=mid+1;;
          } else{
           right=mid-1;
           }      
         } 
        return -1;
}

（2）、冒泡排序

//基础版本：
pubic static int bubbleSort(int[]a){
    for(int i=0;i<a.length;i++){
        for(int j=1;j<a.length-i;j++){
                 if(a[j]>a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
            }
      }
   }
}
//优化版本：（节省时间，若数组有序就不需要再一次的进行判断）
public static void bubbleSort(int[]a){
    for(int i=0;i<a.length;i++){
        boolean sorted=true;//假设数组是有序地 
        for(int j=1;j<a.length-i;j++){
                 if(a[j-1]>a[j]){
                    int temp=a[j-1];
                    a[j-1]=a[j];
                    a[j]=temp;
                    sorted=false;
            }    
      }
      if(sorted==true){
                return;
            }
   }

(3)、求取数组中除去最大值与最小值的平均值

public static double average(int[] a){
 int sum=0;
 int max=Integer.MIN_VALUE; //Integer类包装一个对象中的原始类型int的值。
// 类型为Integer的对象包含一个单一字段，其类型为int 。
 int min=Integer.MAX_VALUE;
for(v:a){
sum+=v;
if(v>max){
max=v;
}
if(v<min){
min=v;
}
}
return (double)(sum-max-min)/(a.length-2);
}

(4)、将数组中的值向右旋转k位

/*System.arraycopy(源数组引用，源下标，目标数组引用，目标下标，长度（即要复制的数组元素的个数）)；将指定源数组中的数组从指定位置复制到目标数组的指定位置
Arrays.copyOf(int[] a,int newLength);
Arrays.copyOfRange(int[] a,int from,int to);//a[from,to)
eg:int[] nums={1,2,3,4,5};
k=3   ->  {3,4,5,1,2}
k=8    ->{ 3,4,5,1,2}*/
public static int[] rotate(int[] nums,int k){
    k=k%nums.length;
   int[] rightPart=Arrays.copyOfRange(nums,nums.length-k,nums.length);
   //拷贝右边数组的部分 数组元素数个数为K个
   System.arraycopy(nums,0,nums,k,nums.length-k);
   //拷贝左边数组部分 拷贝到nums数组中，数组中元素个数为nums.length-k个
   System.arraycopy(rightPart,0,nums,0,k);
   return nums;
}
public static void main(String[]args){
    System.out.println(Arrays.toString(rotate(new int[]{1,2,3,4,5},3)));
}

(5)、将数组中的偶数放在奇数的前面

/*方法一：分别设定两个数 一个begin指向数组中的第一个元素，
另一个end指向数组中的最后一个元素，两个数分别向中间移动，若begin指向
了奇数，end指向了偶数，则将这两个数所指向的数组元素进行交换*/
import java.util.Arrays;
public static void swap(int[] a,int i,int j){
    int t=a[i];
    a[i]=a[j];
    a[j]=t;
}
​public static int[] partition1(int[] nums){
    int begin=0;
    int end=nums.length-1;
//从【begin,end】区间内的数是未判断的数
        //[0,begin) 偶数
        //【end,nums.length）奇数
     while(begin<end){
            while(begin<end&&nums[begin]%2==0){
                    begin++;
                }
            while(begin<end&&nums[end]%2!=0){
                    end--;
                    swap(nums,begin,end); 
         }
     }
return nums;
}
public static void main(String[]args){
System.out.println(Arrays.toString(partition1(new int[]{1,4,2,3,7,8,6})));
}
/*方法二：设定两个数i,b都指向数组的第一个元素，让其中一个元素i向后移动 遍历整个数组
 在遍历的过程中，若i所指向的数为偶数，b所指向的数为奇数，则交换他们所指向的数，
否则b,i向后移动。*/​​
public static int[] partition2(int[] nums){
int b=0;
for(int i=0;i<nums.length;i++){
    if(nums[i]%2==0){
        swap(nums,i,b);
        b++;
  }
}
return nums;
}

4.数组的操作：
1）根据下标访问对应的元素a[index] 0<=index<length
遇到的异常有：NullPointerException/ArrayIndexOutOfBounds
2)获取数组的长度 a.length
遇到的异常 当a.length为空时 异常为：NullPointerException
5、数组的遍历
int []a={1,2,3,4,5};
for(int i=0;i<a.length;i++){
a[i];
}

for(int element:a){ //foreach 形式
element
}
其中有什么不对的地方，还请大家多多指教。