黑馬程序員——java數組篇

------- android培訓、java培訓、期待與您交流！ ----------

一、數組的定義

   概念：同一種類型數據的集合。其實數組就是一個容器。

   數組的好處：能夠自動給數組中的元素從0開始編號，方便操做這些元素。

   格式1：元素類型[] 數組名= new 元素類型[元素個數或數組長度];

   示例：int[] arr = new int[5];

   格式2：元素類型[] 數組名= new 元素類型[]{元素，元素，……};

       int[] arr= new int[]{3,5,1,7};

       int[] arr= {3,5,1,7};

二、數組的內存分配及特色

   數組內存結構

   內存結構

   Java程序在運行時，須要在內存中的分配空間。爲了提升運算效率，有對空間進行了不一樣區域的劃分，由於每一片區域都有特定的處理數據方式和內存管理方式。

棧內存：用於存儲局部變量，當數據使用完，所佔空間會自動釋放。

堆內存：數組和對象，經過new創建的實例都存放在堆內存中。每個實體都有內存地址值。實體中的變量都有默認初始化值。實體不在被使用，會在不肯定的時間內被垃圾回收器回收。

方法區，本地方法區，寄存器。

三、數組操做常見問題

   數組腳標越界異常(ArrayIndexOutOfBoundsException) 訪問到了數組中的不存在的腳標時發生。

       int[] arr= new int[2];

       System.out.println(arr[3]);

   空指針異常(NullPointerException) arr引用沒有指向實體，卻在操做實體中的元素時。

       int[] arr= null;

       System.out.println(arr[0]);

四、數組常見操做

   獲取最值(最大值，最小值)

/*
給定一個數組{5,1,6,4,2,8,9}
1，獲取數組中的最大值，以及最小值。
思路：
遍歷數組，並比較相鄰的元素，將符合條件的賦值給一個變量。
*/
class ArrayTest
{
    public static void main(String[] args)
    {
        int[] arr = {2,4,3,5,7,8};
        int max = getMax_2(arr);
        System.out.println(max);
        int min = getMin(arr);
        System.out.println(min);
    }
    public static int getMax(int[] arr)
    {
        int max = arr[0];
        for (int x=0;x<arr.length;x++ )
        {
            if(arr[x]>max)
                max = arr[x];  
        }
        return max;
    }
    public static int getMax_2(int[] arr)
    {
        int max = 0;
        for (int x=1;x<arr.length;x++ )
        {
            if (arr[x]>arr[max])
                max = x;
        }
        return arr[max];
    }
    public static int getMin(int[] arr)
    {
        int min = 0;
        for (int x= 1;x<arr.length ;x++ )
        {
            if (arr[x]<arr[min])
            {
                min = x ;
            }
        }
        return arr[min];
    }
}

   排序（選擇排序，冒泡排序）

/*
對給定數組進行排序。
{5,1,6,4,2,8,9}
*/
class ArrayTest2
{
    /*
    選擇排序。
    內循環結束一次，最值出如今頭角標位置上。
    */
    public static void selectSort(int[] arr)
    {
        for (int x=0;x<arr.length-1;x++)
        {
            for (int y=x+1;y<arr.length;y++ )
            {
                if (arr[x]>arr[y])//更改比較符號就能選擇升序或降序
                {
                    /*
                    int temp =arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                    */
                    swap(arr,x,y);
                }
            }
        }
                                                                 
    }
    /*
    冒泡排序。 
    */
    public static void bubbleSort(int[] arr)
    {
        for (int x=0;x<arr.length-1;x++)
        {
            for (int y=0;y<arr.length-x-1;y++)//-x：讓每次比較元素減小，-1：避免角標越界。
            {
                if (arr[y]>arr[y+1])
                {
                    /*
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                    */
                    swap(arr,y,y+1);
                }
            }
        }
    }
    /*
    發現不管什麼排序，都須要對知足條件的元素進行位置置換。
    因此能夠把這部分相同的代碼提取出來，單獨封裝成一個函數
    */
    public static void swap(int[] arr,int a,int b)
    {
        int temp =arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    public static void main(String[] args)
    {
        int[] arr = {5,1,6,4,2,8,9};
        printArray(arr);
        //selectSort(arr);
        bubbleSort(arr);
        printArray(arr);
        //Array.sort(arr);//java中已經定義好的一種排序方式。開發中對數組排序要使用該句代碼。
    }
    public static void printArray(int[] arr)
    {
        System.out.print("[");
        for (int x= 0;x<arr.length;x++ )
        {
            if(x!=arr.length-1)
                System.out.print(arr[x]+",");
            else
                System.out.println(arr[x]+"]");
        }
    }
}

   折半查找(二分查找)

/*
數組的查找操做。
練習：有一個有序的數組，想要將一個元素插入到該數組中，
還要保證該數組是有序的。如何獲取該元素在數組中的位置。
*/
class ArrayTest4
{
    public static void main(String[] args)
    {
        int[] arr = {32,34,53,35,12,13};
        int x = getIndex(arr,34);
        System.out.println("所查找的數是第"+(x+1)+"個");//錯誤的把方法中返回的x看成此處的x。
        int[] arr1={1,4,6,8,13,23,45,67,123};
        System.out.println("插入的位置"+(getIndex_2(arr1,12)+1));
    }
    //插入函數
    public static int getIndex_2(int[] arr,int key)
    {
        int min=0,max=arr.length,mid;
        while (min<=max)
        {
            mid = (min+max)>>1;
            if (key>arr[mid])
                min=mid+1;
            else if (key<arr[mid])
                max=mid-1;
            else
                return mid;
        }
            return min;
    }
    /*
    折半的第二種方式。
    */
    public static int halfSearch_2(int[] arr,int key)
    {
        int min=0,max=arr.length,mid;
        while (min<=max)
        {
            mid = (min+max)>>1;
            if (key>arr[mid])
                min=mid+1;
            else if (key<arr[mid])
                max=mid-1;
            else
                return mid;
        }
            return -1;
    }
    /*
    折半查找.提升效率。可是必需要保證該數組是有序的數組。
    */
    public static int halfSearch(int[] arr,int key)
    {     
        int max = arr.length-1;
        int min = 0;
        int mid = (max+min)/2;
        while (arr[mid]!=key)
        {
            if (arr[mid]>key)
                max=mid-1;    
            else
                min=mid+1;
            if (min>max)
                return -1;
            mid=(max+min)/2;
        }
                return mid ;
        }
    //定義功能：獲取key第一次出如今數組中的位置。若是返回的是-1，那麼表明該key在數組中不存在。
    public static int getIndex(int[] arr,int key)
    {
        for (int x=0;x<arr.length;x++)
        {
            if (arr[x]==key)
            {
                return x;
            }
        }
        return -1;
    }
}

       練習：進制轉換

class ArrayTest7
{
    public static void main(String[] args)
    {
        toBin(6);
        toBa(60);
        toHex(60);
    }
    /*
    十進制-->二進制
    */
    public static void toBin(int num)
    {
        trans(num,1,1);
    }
    /*
    十進制-->八進制
    */
    public static void toBa(int num)
    {
        trans(num,7,3);
    }
    /*
    十進制-->十六進制
    */
    public static void toHex(int num)
    {
        trans(num,15,4);
    }
    //定義一個轉換方法。
    public static void trans(int num,int base,int offset)
    {
        //定義表
        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;
        //當傳入的num爲0時。
        if (num==0)
        {
            arr[--pos] = chs[num];
        }
                                                  
        while (num!=0)
        {
            int temp = num & base;
            arr[--pos] = chs[temp];
            num = num >>> offset;
        }
        System.out.print("[");
        for (int x=pos;x<arr.length;x++ )
        {
            if(x!=arr.length-1)
                System.out.print(arr[x]+",");
            else
                System.out.println(arr[x]+"]");
        }
    }
}

   五、數組中的數組

   5.1二維數組[][]

       格式1：int[][] arr = new int[3][2];

       定義了名稱爲arr的二維數組；二維數組中有3個一維數組；每個一維數組中有2個元素；一維數組的名稱分別爲arr[0], arr[1], arr[2]；給第一個一維數組1腳標位賦值爲78寫法是：arr[0][1] = 78;

       格式2：int[][] arr = new int[3][];

       二維數組中有3個一維數組；每一個一維數組都是默認初始化值null；能夠對這個三個一維數組分別進行初始化：arr[0] = new int[3];arr[1] = newint[1];arr[2] = new int[2];

       格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

       定義一個名稱爲arr的二維數組；二維數組中的有三個一維數組；每個一維數組中具體元素也都已初始化；第一個一維數組arr[0] = {3,8,2};第二個一維數組arr[1] = {2,7};第三個一維數組arr[2] = {9,0,1,6};第三個一維數組的長度表示方式：arr[2].length;

注意特殊寫法狀況：int[] x,y[]; x是一維數組，y是二維數組。

   5.2數組的內存分配棧內存和堆內存

       如定義一個數組 int[]scores將在棧內存中爲scores 分配內存空間，其值是一個不肯定的值。

       當執行語句scores=new int[5]時，將在堆內存分配連續5個空間，每一個空間4個字節，用於存放整型數據，其初始值爲0，而後將該段空間首地址，也就是第一個元素的地址，好比0x3543，賦給scores變量。該地址至關於一個指針，指向堆內存中分配的空間。此時堆內存中分配的5個空間能夠分別使用scores[0],一直到scores[4]來表示。當執行四個賦值語句時，分別用指定值填充到對應元素位置。若是此時將null值賦給scores時，scores變量將再也不指向任何位置，此時堆內存中分配的空間就變成了垃圾，由垃圾回收器在某一時間進行回收。

       在方法中定義的變量，包括基本數據類型變量和引用數據類型變量，都將在棧內存中分配空間，當超過變量做用範圍後，自動回收。