黑马程序员--数组

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
数组：同一类型数据的集合。数组是一个容器。
好处：自动给数组中的元素从0开始编号，方便操作数组。

格式1：
元素类型[] 数组名=new 元素类型[元素个数或数组长度]；
eg: int[] arr=new int[5];
格式2：
元素类型[] 数组名=new 元素类型[]{元素，元素，…};
eg: int[] arr=new int[]{1,2,3,4};
eg: int[] arr={1,2,3,4};

常见错误：
1数组角标越界 ArrayIndexOutofBoundsException操作数组时访问到数组中不存在的角标。
2空指针异常 NUllPointerException 当引用没有任何指向，值为空的情况，该引用还在用于操作实体。

常见操作：
1. 获取数组中的元素
遍历数组 (arr.length数组长度)

int[] arr=new int[3];
for(int i=0;i<arr.length;i++){
        arr[i];
}

.2.获取最值

public static int getMax(int[] arr){
        int max=arr[0];
for(int x=1;x<arr.length;i++){
        if(arr[x]>max)
            max=arr[x];
}
return max;
}

其中将arr[x]>max的大于号改为小于号 可以获取最小值
3. 排序 在所有的排序中希尔排序效率最高
由于排序过程中一定会出现交换数值因此可以将交换的方法提取出来达到代码的复用
元素的交换能使用两种方法，在下面都给出来了。

public static void swap(int[] arr,int a,int b){
        //方法1：定义第三方变量
        int temp=arr[a];
        arr[a]=arr[b];
        arr[b]=temp;
        //方法2：不定义第三方变量
//      arr[a]=arr[a]^arr[b];
//      arr[b]=arr[a]^arr[b];
//      arr[a]=arr[a]^arr[b];
    }

(1). 选择排序 （从大到小）

    public static void selectSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i]<arr[j]){
                    swap(arr, i, j);
                }
            }
        }
    }

(2). 冒泡排序 （从大到小）

    public static void bubleSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]<arr[j+1]){
                    swap(arr, j, j+1);
                }
            }
        }
    }

4.查找 查找数组中是否存在某元素。
普通方法;

    public static int getIndex(int[] arr,int key){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==key){
                return i;
            }
        }
        return -1;
    }

-1表示不存在。
这里重点要求掌握的是折半查找。
折半查找方法1：

    public static int halfSerach(int[] arr,int key){
        int min,max,mid;
        min=0;
        max=arr.length-1;
        mid=(max+min)/2;
        while(arr[min]!=key){
            if(key>arr[mid])
                min=mid+1;
            else if(key<arr[mid])
                max=mid-1;

            if(min>max)
                return -1;
            mid=(mid+max)/2;
        }
        return mid;
    }

折半查找方法2：

public static int halfSerach_2(int[] arr,int key){
        int min=0,max=arr.length-1,mid;
        while(min<=max){
            mid=(max+min)>>1;

        if(key>arr[mid])
            min=mid+1;
        else if(key<arr[min])
            min=mid-1;
        else 
            return mid;

        }
        return -1;
    }

折半查找面试题：
有一个有序数组，想要将一个元素插入到该数组中，还要保证该数组有序
解决方法： 通过折半查找找到插入元素应该插入到数组中的位置 返回的min值就是所要的位置
使用数组作为容器进行进制转换：
普通方法：

    /**
     * 十进制转换为2进制（有局限性 num必须大于0）
     * 先穿建一个StringBuffer对象，当num>0时将num%2 存进去然后num/2 最终使用StringBuffer提供的反转方 法reverse将结果输出
     */
    public static void toBin(int num){
        StringBuffer sb=new StringBuffer();
        while(num>0){
            sb.append(num%2);
            num=num>>1;
        }
        System.out.println(sb.reverse());
    }

优化方法：通过查表法
进行进制转换
十进制转换为十六进制(查表法) num是负数也行，将所有的元素临时存储起来，建立对应关系，每一次&15后的值作为索引去查建立好的表 就可以找到对应的元素，这样比 -10+’A’简单的多，可以通过数组形式定义建立的表，通过数组作为临时容器存储
相同代码抽取：

    /**
     * 根据参数转换进制的方法
     * @param num 要转换的数字
     * @param base 要&的基数
     * @param offset 偏移量
     */
    public static void trans(int num,int base,int offset){
        if(num==0){
            System.out.print(0);
            return;
        }
        char[] chs={'0','1','2','3',
                '4','5','6','7',
                '8','9','A','B',
                'C','D','E','F',};
        char[] arr=new char[32];
        //定义指针
        int pos=arr.length;
        while(num!=0) 
        {
            int temp=num&base;
            arr[--pos]=chs[temp];
            num=num>>>offset;
        }
        //打印结果arr数组
        for (int i = pos; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
    十进制转换为十六进制：
    public static void toBin(int num){
        trans(num, 1, 1);
    }
    十进制转换为八进制;
    public static void toOct(int num){
        trans(num, 7, 3);
    }
    十进制转换为十六进制:
    public static void toHex(int num){
        trans(num, 15, 4);
    }