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));
    }
}