5、数组与数组排序

一、

　　当一个方法执行时，每个方法都会建立自己的内存栈，所有方法中定义的变量都是放在占内存中。我们在程序中创建对象时，这个对象保存到了动态内存区，以便反复使用，这个运行时数据区就是堆内存。堆内存中的对象不会随方法的结束而马上销毁，即使方法结束后，该对象还可以被另一个应用变量所引用，则该对象不会被销毁，只有当一个对象没有任何引用变量所引用，系统垃圾回收机制在合适的时候回收它。

　　静态内存在栈(stack)上分配; 动态内存在堆(heap)上分配。静态内存分配在编译时完成，不占用CPU资源; 动态内存分配在运行时，分配与释放都占用CPU资源。动态内存分配需要指针和引用类型支持，静态不需要。静态内存分配是按计划分配，由编译器负责; 动态内存分配是按需分配，由程序员负责。

二、数组是一个引用类型，数组变量放在栈内存中，存放首地址 。

　　数组声明：int []x;

　　数组初始化：x=new int[100];

　　int [] x=new int[100];　　数组中元素默认值为0.

　　int []b={1,2,3,4,5,6,7,8};

　　int []c=new int []{1,2,3,4};

　　越界会有ArrayIndexOutOfBoundsException：数组越界异常

　　一旦创建数组之后就不能改变其大小。

　　静态赋值：就是在初始化过程中就赋值了；动态赋值：通过for循环来进行赋值。

三、foreach循环

　　JDK1.5新增的循环增强

　　for(Type variable:collection){
　　　　}

　　　特点：只读！！不可写！性能高

四、length

　　数组中为属性：a.length

　　字符串中为方法：a.length();

五、手动操作一维数组的几个方法

　　1、求数组中最大值的最优解

public class B {//求数组中最大值的最优解（三目运算符、foreach)
    public static void main(String[] args) {
        int a[]={1,2,3,4,5,6,8,7};
        int temp=a[0];
        for(int i:a){
            temp=temp<i?i:temp;
        }
        System.out.println(temp);
    }
}

　　2、数组复制

public class C {
    public static void main(String[] args) {//数组复制
       int []a={1,2,3,4,5,6,7,8,9};
       int []b=new int[a.length];
       int j=0;
       for(int i:a){
           b[j++]=i;
       }
       for(int i:b){
           System.out.println(i);
       }
    }

　　3、倒序输出

public class D {//倒序输出（折半法）
    public static void main(String[] args) {
        int []a={1,2,3,4,5,6,7,8,9};
        for(int i=0;i<a.length;i++){
            System.out.println(a[a.length-1-i]);
        }
    }
}

　　

六、用JDK自带方法解决一维数组问题

　　1、import java.util.Arrays;

　　a、用同一个元素填充数组

       Arrays.fill(a,10);
        for(int i:a){
            System.out.println(i);
        }

　　b、给b数组创建新堆，用另一个数组的内容赋值给b数组，多余位置补0

b=Arrays.copyOf(a,10);
        for(int i:b){
           System.out.println(i);
        }

　　c、自带快排

Arrays.sort(a);
            for(int i:a){
                System.out.println(i);
            }

　　2、在System中的方法

　　　　数组复制（不可以越界）

 System.arraycopy(a,0,b,0,5);
       for(int i:b){
           System.out.println(i);
       }

七、二分查找

　　前提：都需要先排序！

　　手动版：

 public static int binarysearch(int key,int a[]){
        int low=0;
        int high=a.length;
        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

　　JDK版：

Arrays.binarySearch(a,7)

 　　没有查找到的话返回将要查找的位置去负减一；

八、二维数组

　　1、初始化：int [][]b=new int[3][];

　　 　　　数组的行位置上必须填写数字，而列上的不必要。

　　当没有给予列数字时候，后面需要补充初始化：

　　　　　　b[0]=new int[2];(在第0行，有2列）

　　　　　　每一行的列可以不同。

　　　　　　默认初始化赋值为0；

　　快速初始化：int [][]a={{1,2},{3,4},{5,6}};

　　

　　2、遍历

for(int i=0;i<=2;i++){
            for(int j=0;j<c[i].length;j++){
                System.out.println(c[i][j]);
            }
        }

　　3、二维数组的foreach遍历

 for(int []i:c){
            for(int j:i){

            }
        }

　　九、快排、冒泡加二分代码

package com.zxc.E;

/**
 * Created by Administrator on 2018/1/31 0031.
 */
public class QuickSort1 {
    public static void main(String[] args) {
        int a[]={3,6,1,8,4,9};
        //QuickSort(a,0,a.length-1);
        BubbleSort(a);
        System.out.println(BinarySearch(3,a));
    }

    static void BubbleSort(int []a){
        for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-1-i;j++){
                if(a[j]>a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
    }

    static void QuickSort(int []a,int start ,int end){
        int i=start;
        int j=end;
        if(i>=j){
            return;
        }
        boolean flag=true;
        while(i!=j){
            if(a[i]>a[j]){
                int temp=a[i];
                a[i]=a[j];
                a[j]=temp;
                flag=!flag;
            }
            if(flag){
                j--;
            }else{
                i++;
            }
        }
        i--;
        j++;
        QuickSort(a,start,i);
        QuickSort(a,j,end);
    }
    static int BinarySearch(int key,int []a){
        int high=a.length;
        int low=0;
        while(high>=low){
            int mid=(low+high)/2;
            if(key>a[mid]){
                low=mid+1;
            }else if(key<a[mid]){
                high=mid-1;
            }else{
                return mid;
            }
        }
        return -1;
    }
}