1. 程式人生 > >java資料結構之陣列(Array)

java資料結構之陣列(Array)

最近一直在學習資料結構,於是乎就想寫一篇部落格記錄下自己所學,順便把知識鞏固下,畢竟資料結構嘛,是一切程式設計的基礎,‘’雄關漫道真如鐵,而今邁步從頭越‘’。。。。。。一切的一切都要從頭開始,只有基礎好了,寫起程式來才能6666。

注:以下內容 ,有參考別人的部落格總結出來的,前人栽樹,後人乘涼,最後感謝那位大神,謝謝你的默默付出。

陣列概述:

1、陣列可以看成是多個相同資料型別資料的組合,對這些資料的統一管理。

2、陣列變數屬引用型別,陣列也可以看成是物件,陣列中的每個元素相當於該物件的成員變數。

3、陣列中的元素可以是任何型別,包括基本型別和引用型別。

一維陣列的宣告:

1、一維陣列的宣告方式:

type var[];   或type[] var;

例如:

int a1[];     int[] a2;    double b[];     Person[] p1;     String s1[];

2、java語言中宣告陣列時不能指定其長度(陣列中元素的個數),例如:

int a[5];  //非法

陣列物件的建立:

1、java中使用關鍵字new 建立陣列物件,格式為:

陣列名 = new 陣列元素型別[陣列元素個數];

例如:

public class TestArray{
    public static void main(String args[]){
        int[] arr;
        arr = new int[5];
        for(int i=0;i<5;i++){
            arr[i] = i;
            System.out.println(arr[i]);
        }
    }
}

2、元素為引用型別的資料(注意:元素為引用資料型別的陣列中的每一個元素都需要例項化)

例如:

public class TestArray{
    public static void main(String args[]){
        Date[] date;
        date = new Date[3];
        for(int i=0; i<3; i++){
            date[i] = new Date(2014,10,25);
            System.out.println(date[i].year+"年,"+date[i].month+"月,"+date[i].day+"日!");
        }
    }
}
class Date{
    int year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

 陣列初始化:

1、動態初始化:

陣列定義與為陣列元素分配空間和賦值的操作分開進行,例如:

public class TestArray{
    public static void main(String args[]){
        int[] arr = new int[3];        //陣列定義
        arr[0]=1;    //陣列初始化
        arr[1]=2;
        arr[2]=3;
        
        Date[] date = new Date[3];    //陣列定義
        date[0] = new Date(2014,10,25);        //陣列初始化
        date[1] = new Date(2014,10,25);
        date[2] = new Date(2014,10,25);
        
    }
}
class Date{
    int year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

2、靜態初始化

在定義陣列的同時就為陣列元素分配空間並賦值,例如:

public class TestArray{
    public static void main(String args[]){
        int a[] = {1,2,3};
        Date[] date = {new Date(2014,10,25), new Date(2014,10,26), new Date(2014,10,27)};
    }
}
class Date{
    int year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

3、陣列元素的預設初始化:

陣列時引用型別,它的元素相當於類的成員變數,因此陣列分配空間後,每個元素也被按照成員變數的規則被隱式初始化,例如:

public class TestArray{
    public static void main(String args[]){
        int[] a = new int[3];
        Date[] date = new Date[3];
        System.out.println(a[2]);
        System.out.println(date[2]);
    }
}
class Date{
    int year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

陣列元素的引用:

1、定義並用運算子new為之分配空間後,才可以引用陣列中的每個元素,陣列元素的引用方式為:

  ①、arrayName[index]

    index為陣列元素下標,可以使整形常亮或整形表示式。如:

    a[3], b[i], c[6*i];

  ②、陣列元素的下標從0開始;長度為n的陣列的合法下標取值範圍為:

    0~n-1;

2、每個陣列都有一個屬性lendth(注:這裡length是一個屬性,不是方法,沒有加括號(),我們這裡特別說明是為了和String的length()方法做區別)指明他的長度,例如:

  a.length的值為陣列a的長度(元素個數)

  注: 

     public static void main(String args[]){}

     我們每個類中的主函式也有一個數組,名叫srgs,那麼這個陣列時幹嘛用的呢?這個陣列就好比,我們在命令列中注入 ipconfig -all 中的all. 我們可以在輸入             java TestArray(類名) 23,12,aa,bbb  這個跟幾個引數。然後可以在程式碼中輸出來看到。   

  注(基礎型別的包裝類):

        基礎型別的包轉類, 基礎型別是分配在棧記憶體中的  , 包裝類是分配在堆空間裡面的  。

           基礎型別的包裝類有:Boolean---boolean 、 Byte---byte 、 Character---char 、 Double---double  、 Float---float  、 Integer---int  、 Long---            long 、 Short---short   通常我們使用parsexxx()方法來將string型別轉換為我們想要的資料型別。我們也可以使用string型別的valueOf()方法將想要的              資料型別轉換為string型別。

下面我們舉一個args[]引數和基礎型別包裝類一起使用的例子,用來計算+-x/:

public class TestArgs{
    public static void main(String args[]){
        if(args.length<3){
            System.out.println("error~~~");
            System.exit(0);
        }
        double  b1 = Double.parseDouble(args[0]);
        double  b2 = Double.parseDouble(args[2]);
        double  b = 0;
        if(args[1].equals("+")){
            b = b1 + b2;
        }else if(args[1].equals("-")){
            b = b1-b2;
        }else if(args[1].equals("x")){
            b = b1*b2;
        }else if(args[1].equals("/")){
            b = b1/b2;
        }else{
            System.out.println("error operation!!!");
        }
        System.out.println(b);
    }
}

ars輸入10個數,並且用選擇排序,從小到大排序的示例:

public class TestSortInt{
    public static void main(String args[]){
        int[] a = new int[args.length];
        for(int i=0; i<args.length; i++){
            a[i] = Integer.parseInt(args[i]);
        }
        int k,temp;
        for(int i=0; i<a.length; i++){
            k = i;
            for(int j=i+1; j<a.length; j++){
                if(a[k]>a[j]){
                    k=j;
                 }
            }
            if(k!=i){
                temp = a[i];
                a[i] = a[k];
                a[k] = temp;
            }
        }
        for(int i=0; i<a.length; i++){
            System.out.print(a[i] + " ");
        }
    }
}

下面我們用數組裡面裝一個日期型別做排序的示例,用了氣泡排序。

public class TestDateSort{
    public static void main(String args[]){
        Date[] date = new Date[5];
        date[0] = new Date(2006,5,4);
        date[1] = new Date(2006,7,4);
        date[2] = new Date(2008,5,4);
        date[3] = new Date(2004,5,9);
        date[4] = new Date(2006,5,4);
        
        bubbleSort(date);
        
        for(int i=0; i < date.length; i++){
            System.out.println(date[i]);
        }
    }
    public static Date[] bubbleSort(Date[] a){
        int len = a.length;
        for(int i=len; i>=1; i--){
            for(int j=0; j<i-1; j++){
                if(a[j].compare(a[j+1])>0){
                    Date temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                }
            }
        }
        return a;
    }
}
class Date{
    private int year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public int compare(Date date){
        return year>date.year?1
               :year<date.year?-1
               :month>date.month?1
               :month<date.month?-1
               :day>date.day?1
               :day<date.day?-1
               :0;
    }
    public String toString(){
        return "year,month,day ---- " +year+" - "+month+" - "+day;
    }
}

下面我們用陣列做一個數三退一的遊戲,就是說,好多人圍城一圈,數1,2,3三個數,數到3的人退出,剩餘的人繼續重新從1開始數數,知道剩下最後一個人,我們用陣列求最後一個人是誰?  

在這個示例中,我們假設有500個人手拉手圍城一圈在數數,最後是下標為435這個人贏了,也就是第436個人贏了!~~~

public class Count3Quit{
    public static void main(String args[]){
        boolean[] arr = new boolean[500];
        for(int i=0; i<arr.length; i++){
            arr[i] = true;
        }
        
        int leftCount = arr.length;
        int count = 0;
        int index = 0;
        while(leftCount > 1){
            if(arr[index] == true){
                count++;
                if(count == 3){
                    count = 0;
                    arr[index] = false;
                    leftCount --;
                }
            }
            index ++;
            if(index == arr.length){
                index=0;
            }
        }
        
        for(int i=0; i<arr.length; i++){
            if(arr[i]==true){
                System.out.println(i);
            }
        }
    }    
}

複製程式碼

 有了陣列之後,我們可以設計各種各樣的排序演算法。然後在排好序的時候,我們又可以設計各種各樣的查詢演算法,接下來,我們用陣列實現一個簡單的二分法查詢演算法

public class TestSearch{
    public static void main(String args[]){
        int[] a = {12,23,41,53,24,57,32,52,98,43,19,73};
        int postion = binarySearch(a,57);
        System.out.println(postion);
    }
    public static int binarySearch(int[] a, int searchNum){
        
        if(a.length==0)return -1;
        
        int startFlag = 0;
        int endFlag = a.length-1;
        int m = (startFlag+endFlag)/2;
        while(startFlag<=endFlag){
            if(a[m] == searchNum){
                return m;
            }else if(a[m]<searchNum){
                startFlag = m+1;
            }else if(a[m]>searchNum){
                startFlag = m+1;
            }
            m = (startFlag+endFlag)/2;
        }
        return -1;
    }
}

 二維陣列:

  1、二維陣列可以看成是以陣列為元素的陣列。例如:

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

  2、java中多維陣列的宣告和初始化應按從高維到低維的順序進行,例如:

    int a[][] = new int[3][];

    a[0] = new int[2];

    a[1] = new int[4];

    a[2] = new int[3];

    int t1[][] = new int[][4];//這種宣告是非法的

二維陣列初始化:

1、靜態初始化:

    int intA[][] = {{1,2},{2,3},{3,4,5}};

    int intB[3][2] = {{1,2},{,2,3},{4,5}};//非法宣告方式

   2、動態初始化:

    int a[][] = new int[3][5];

    int b[][] = new int[3][];

      b[0] = new int[2];

      b[1] = new int[3];

      b[2] = new int[5];

二維陣列舉例:

public class Test{
    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++){
            for(int j=0; j<a[i].length; j++){
                System.out.print("["+i+"]"+"["+j+"]="+a[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

 二維陣列舉例(引用型別的二維陣列):

public class Test{
    public static void main(String args[]){
        String s[][];
        s = new String[3][];
        s[0] = new String[2];
        s[1] = new String[3];
        s[2] = new String[2];
        
        for(int i=0; i<s.length; i++){
            for(int j=0; j<s[i].length; j++){
                s[i][j] = new String("我的位置是:"+i+","+j);
            }
            System.out.println();
        }
        for(int i=0; i<s.length; i++){
            for(int j=0; j<s[i].length; j++){
                System.out.print(s[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

陣列的拷貝:

  1、使用java.lang.system類的靜態方法

    public static void arrayCopy(object src,int srcPos,object dest,int destPos,int length){}

  2、可以用於陣列src從第srcPos項元素開始的length個元素拷貝到目標陣列從destPos項開始的lenght個元素。

  3、如果源資料數目超過目標陣列邊界會丟擲IndexOutOfBoundsException異常。

資料拷貝舉例:

import java.lang.System;
public class TestArrayCopy{
    public static void main(String args[]){
        String[] s = {"Microsoft","IBN","Sun","Oracle","Apple"};
        String[] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        
        for(int i=0;i<sBak.length;i++){
        System.out.print(sBak[i]+" ");
        }
        System.out.println();
        
        int[][] intArray = {{1,2},{1,2,3},{3,4}};
        int[][] intArrayBak = new int[3][];
        System.arraycopy(intArray,0,intArrayBak,0,intArray.length);
        intArrayBak[2][1] = 100;
        
        for(int i=0;i<intArray.length;i++){
            for(int j=0;j<intArray[i].length;j++){
                System.out.print(intArray[i][j]+" ");
            }
            System.out.println();
        }
    }
}

到此為止,資料的基本知識就講完了。學會了陣列更重要的是為我們以後學習排序演算法之類的~~打下了基礎,這才是更重要的!!!