2013.8.7Java語言基礎——數組

　　數組是數據類型一致的變量的集合。

一個：變量

一堆（多個）：數組

數組語法：

1）數組變量（引用類型變量）

　　數組變量通過引用地址引用了數組（數組對象）

2）數組（數組對象）

　　數組就是個體，是一個整體

　　數組元素的個數叫數組的長度length

　　數組元素的范圍：0 1 2…length-1

3）數組元素

　　是數組中的每個變量，使用[下標]訪問

1. 定義數組變量；
2. 創建數組（數組對象）
3. 訪問數組元素?

public class Test {

    public static void main(String[] args) {
        //1)定義數組變量 
        int[] ary;//聲明int[] 數組類型的變量ary
        int ary1;//也是聲明數組變量，但很少使用！！！
        //System.out.println(ary[0]);//編譯錯誤，ary沒有初始化
        ary = null;//null 空，沒有
        //System.out.println(ary[0]);//運行異常，空指針異常
        
        //空指針異常發生原因：引用類型的變量值是null，不引用任何對象
        //當利用引用變量訪問屬性（數組元素）和方法時，出現空指針異常
        
        //2）創建數組（創建 數組對象）
        ary = new int[3];//數組對象有3個元素
        //創建數組對象（new int[3]），將對象的引用賦值給ary變量
        //ary就引用了數組對象，這個對象有3個元素
        System.out.println(ary[0]);//0
        //System.out.println(ary[3]);//運行異常，數組下標越界
        //java數組元素是自動初始化的，初始值為零值，各種零值如下：
        //0 0.0 \u0000 null false
        double[] d = new double[3];
        System.out.println("d[0] = "+d[0]);//d[0] = 0.0
        char[] c = new char[3];
        System.out.println("c[0] = "+c[0]);//c[0] = （看不出顯示什么）
        System.out.println((int)'\u0000');//\u0000的編碼值是0
        String[] s = new String[3];
        System.out.println("s[0] = "+s[0]);//s[0] = null（字符串數組初始化是null）
        boolean[] b = new boolean[3];
        System.out.println("b[0] = "+b[0]);//b[0] = false
        
        //java中數組創建的3種方式
        //new 類型[長度]
        //類型是任何類型：基本類型、類類型（String，Integer）
        //長度：變量或常量值：0~Integer.MAX_VALUE
        
        //new 類型[]{元素0，元素1，元素2}
        //直接給出元素，元素直接初始化，元素的個數就是長度
        ary =new int[]{2,3};
        System.out.println(ary[0]);//2
        
        //靜態初始化
        //類型[] 變量={元素0，元素1，元素2}
        int[] ary4 = {2,3,4};
        //靜態初始化“只能用于”聲明變量同時初始化！
        //ary = {4,5,6}//編譯錯誤
        ary = new int[]{4,5,6};//沒有問題
        
        //new int[length]適合創建不知道具體的元素，數量很多
        //new int[]{2,3,4}適合已經知道具體元素，元素比較少
        //{4,5,6}只適合知道元素，并只能使用在聲明變量時直接初始化
        
        //3)訪問數組元素
        //數組元素一旦創建，數組的長度是不可以改變的
        //使用.length屬性可以獲取數組的長度
        //數組不能越界訪問，會出現運行異常
        ary = new int[]{5,6,7};
        System.out.println(ary.length);
        ary[1]++;
        System.out.println(ary[1]);//7
        System.out.println(ary[-1]);//運行異常！下標越界
        //迭代數組元素，迭代數組也稱為遍歷數組，就是逐一處理元素
        for(int i=0;i<ary.length;i++){
            System.out.println(ary[i]);
        }
    }
}

使用數組非常有用的API方法

（使用API方法：API方法封裝了常用算法功能，使用這些功能簡化開發過程，提高開發效率）

　　Arrays.toString：用于字符串表示數組元素

package TestCode;

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        String[] str =new String[]{"A","b","c","d"};
        System.out.println(Arrays.toString(str));//打印出數組元素[A, b, c, d]
    }

　　Arrays.equals：用于比較兩個數組內容是否相等（便捷）

package TestCode;

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        char[] a1 = new char[]{'a','b','c'};
        char[] a2 = new char[]{'a','b','c'};
        char[] a3 = new char[]{'a','c','d'};
        System.out.println(Arrays.equals(a1, a2));//true
        System.out.println(Arrays.equals(a1, a3));//false
    }
}

　　Arrays.sort：用于實現數組排序

package TestCode;

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        char[] a = new char[]{'a','d','f','c','b','g'};
        System.out.println(Arrays.toString(a));//[a, d, f, c, b, g]
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));//[a, b, c, d, f, g]
    }
}

　　Arrays.binarySearch:用于實現有序數組 的二分法查找

只能查找排序后的數組，不然得到的結果不穩定

package TestCode;

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        char[] a = new char[]{'a','d','f','c','b','g'};
        int index= Arrays.binarySearch(a, 'c');
        System.out.println(index);//-2負數找不到
        Arrays.sort(a);
        index= Arrays.binarySearch(a, 'c');
        System.out.println(index);//在排序后數組的第2位
    }
}

?數組的復制

最常見用途：數組的擴容算法

package TestCode;

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        int[] ary1 = {4,5,6};
        int[] ary2 = ary1;//數組變量的賦值，但數組還是同一個。ary1 ary2互相影響
        ary2[1]++;
        System.out.println(Arrays.toString(ary1));//[4, 6, 6]
        System.out.println(Arrays.toString(ary1));//[4, 6, 6]
    //數組的復制：1）使用for循環實現 2）使用API
    //將ary1引用數組進行復制
        int[] ary3 = new int[ary1.length];
        for(int i=0;i<ary1.length;i++){
            ary3[i] = ary1[i];
        }
        ary3[1]++;
        System.out.println(Arrays.toString(ary3));//[4, 7, 6]
        System.out.println(Arrays.toString(ary1));//[4, 6, 6]
        //使用API System.arraycopy()實現復制，比較早期，用C寫的，性能好
        int[] ary4 = new int[ary1.length];
        //參數：源數組，源數組位置，目標數組，目標數組位置，個數
        System.arraycopy(ary1, 0, ary4, 0, ary1.length);
        System.out.println(Arrays.toString(ary1));
        System.out.println(Arrays.toString(ary4));
        //使用Arrays.copyOf()方法（JDK1.5開始出現），底層就是arraycopy
        int[] ary5 = Arrays.copyOf(ary1, ary1.length);
        System.out.println(Arrays.toString(ary1));
        System.out.println(Arrays.toString(ary5));
        
    }
}

數組的擴容 與 追加

1) 數組創建以后長度不可改變
2) 利用更換數組的方式實現擴容算法
3) 更換數組時候，利用復制方法保持原數組內容。

?數組擴容是Java API 實現的常用算法！

?

package TestCode;

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        // 擴容原理：更換新數組
        String[] playlist = { "song1", "song2" };
        System.out.println(Arrays.toString(playlist));
        playlist = new String[] { "song1", "song2", "song3" };
        System.out.println(Arrays.toString(playlist));
        // 擴容：為playlist擴容并追加 新 歌曲 “song4”
        playlist = Arrays.copyOf(playlist, playlist.length + 1);
        playlist[playlist.length - 1] = "song4";
        System.out.println(Arrays.toString(playlist));
        // 1) 復制新數組（增加容量）
        // 2) 替換原數組
        String[] newOne = new String[playlist.length + 1];
        System.arraycopy(playlist, 0, newOne, 0, playlist.length);
        playlist = newOne;
        System.out.println(Arrays.toString(playlist));
    }
}

?

?

?

?

?

?