黑馬程序員——數組

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

一、數組的定義

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

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

數組的格式

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

                  如： int []  arr = new int [3];  也可以寫成： int arr[] = new int[3];

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

                   如： int []  arr = new int []{1,2,3,4,5};

        還有一種簡寫的靜態初始化格式：如： int [] arr={1,2,3,4,5};

        其中：new是用來在堆內存中產生一個容器實體。

二、內存結構

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

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

        堆內存：1、數組和對象，通過new建立的實例都存放在堆內存中。

                      2、每一個實體都有內存地址值。

                      3、實體中的變量都有默認初始化值。

                      4、實體不在被使用，會在不確定的時間內被垃圾回收器回收。

方法區、本地方法去、寄存器後面再詳談，此地不多做介紹。

三、數組操作中常見的問題

1、數組腳標越界異常(ArrayIndexOutOfBoundsException)。例：

             int[] arr = new int[2];

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

            訪問到了數組中的不存在的腳標時發生。

    2、空指針異常(NullPointerException)。例：

            int[]arr = null;

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

             arr引用沒有指向實體，卻在操作實體中的元素時。

四、數組常見操作

1、 數組排序：

        常見的排序方式：冒泡排序和選擇排序。在Java已經定義好了一種排序方式，在開發使用中，直接調用即可。排序的方式有很多，其中最快的排序方式爲希爾排序。

下面是我自己敲的選擇和冒泡兩種排序方式的程序：

        選擇排序程序：

//使用選擇排序方式對指定的數組進行排序

class  Demo
{
    public static void main(String[] args)
    {
        int[] arr= {1,11,5,3,9,55,23,67,18};  //輸出原數組
        printArray(arr);
        selectSort(arr);  //調用排序方法
        printArray(arr);  //輸出排序後的數組
    }

/*
選擇排序
1、先用0角標上的元素依次與其他元素進行比較，將較小值元素存放到0角標。
2、然後再拿1角標上的元素依次進行比較，以此類推。
*/
    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])
                {
                    //arr[x]=arr[y];
                    //arr[y]=temp;
                    swap(arr,x,y);
                }
            }
        }
    }

    //遍歷數組
    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.print(arr[x]+"]");
        }
        //換行
        System.out.println();
    }

    //互換方法
    public static void swap(int[] arr,int a,int b)
    {
        arr[a]=arr[a]^arr[b];
        arr[b]=arr[a]^arr[b];
        arr[a]=arr[a]^arr[b];
    }
}

 輸出結果：

         

 

冒泡排序程序：

//使用冒泡排序方式對指定程序進行排序

class Demo1
{
    public static void main(String[] args)
    {
        int arr[]={22,63,89,13,6};
        //打印原數組
        printArray(arr);
        //調用排序方法
        bubbleSort(arr);
        //打印排序後的數組
        printArray(arr);
    }

    /*
    冒泡排序
    1、先從頭角標相鄰兩個元素之間進行比較，將較大值存放在後一個元素中，然後再與後一個元素的進行比較，直至最大值存放到最後一個元素中。
    2、再重複1操作，每次計較次數減一，一圈比完後存放的較大元素不再參與比較。
    */

    public static void bubbleSort(int[] arr)
    {
        for (int x=0;x<arr.length-1;x++)
        {
            for (int y=0;y<arr.length-1-x;y++)//-x:讓沒每一次比較的元素減少。-1：避免角標越界。
            {
                if(arr[y]>arr[y+1])
                    swap(arr,y,y+1);
            }
        }
    }
    //遍歷數組
    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.print(arr[x]+"]");
        }
        //換行
        System.out.println();
    }

    //互換方法
    public static void swap(int[] arr,int a,int b)
    {
        arr[a]=arr[a]^arr[b];
        arr[b]=arr[a]^arr[b];
        arr[a]=arr[a]^arr[b];
    }
}

 輸出結果

 

2、 折半查找

程序：

/*
需求：將一個已知元素插入到一個有序數組中，要求不改變數組順序，打印元素應該插入數組位置的角標。
思路：1、可以利用折半查找的方式，先定義兩個變量，一個初始化0角標，作爲最小值，一個初始化爲最後一個角標，作爲最大值，
        再定義一個變量，存儲最小值與最大值的一半，也就是中間位置，然後將已知元素與中間值位元素進行比較。
      2、如果比中間值元素大，則將最小值變爲中間值加1，繼續取最小值與最大值的中間值元素與已經元素進行比較，以此反覆
      3、如果比中間值元素小，則將最大值變爲中間值減1，繼續取最小值與最大值的中間值元素與已經元素進行比較，以此反覆
*/
class  HalfSearch
{
    public static void main(String[] args)
    {
        int[] arr={2,6,9,11,15,19,22,30};
        //打印數組
        printArray(arr);
        int key=20;
        //用第一種折半方式輸出插入的角標值
        System.out.println("當key=20在數組arr中插入的角標位置是："+halfSearch1(arr,key));
        key=1;
        //用第二種折半方式輸出插入的角標值
        System.out.println("當key=1在數組arr中插入的角標位置是："+halfSearch2(arr,key));
    }

    //折半查找<一>
    public static int halfSearch1(int[] arr,int key)
    {
        int min=0,max=arr.length-1,mid=(max+min)/2;
        while(key!=arr[mid])
        {
            if(min>max)
                return min;
            else if(key>arr[mid])
                min=mid+1;
            else
                max=mid-1;
            mid=(max+min)>>>1;//折半操作
        }
        return mid;
    }

    //折半查找<二>
    public static int halfSearch2(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[mid])
                max=mid-1;
            else
                return mid;
        }
        return min;
    }

    //遍歷數組
    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.print(arr[x]+"]");
        }
        //換行
        System.out.println();
    }
}

運行結果：

 

3、 進制轉換

十進制轉換爲二進制、八進制、十六進制的小程序：

/*
使用查表法將十進制轉換爲二進制、八進制、十六進制
*/
class  Conversion
{
    public static void main(String[] args)
    {
        int num=60;

        toBin(num);

        toOct(0);

        toHex(-num);
    }

    //轉換爲二進制
    public static void toBin(int num)
    {
        conversion(num,1,1);
    }

    //轉換爲八進制
    public static void toOct(int num)
    {
        conversion(num,7,3);
    }

    //轉換爲十六進制
    public static void toHex(int num)
    {
        conversion(num,15,4);
    }
    //轉換
    public static void conversion(int num,int diwei,int yiwei)
    {
        //如果num等於0，結果輸出爲0
        if(num==0)
        {
            System.out.println("num="+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)
        {
            arr[--pos]=chs[num&diwei];//--pos倒着往臨時容器裏存
            num >>>=yiwei; //無條件右移相應位數
        }

        //打印轉換後的結果
        for(int x=pos;x<arr.length; x++)
            System.out.print(arr[x]);

        //換行
        System.out.println();
    }
}

 輸出結果：

五、數組中的數組——二維數組[][]

也稱多維數組，這裏我們主要講二維數組。

        格式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][];

         注：此種格式中每個一維數組都是默認初始化值null。

         格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};//每一個一維數組中具體元素都初始化了。

注：一種特殊定義寫法：int[]x,y[]; x是一維數組，y是二維數組。

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