首页 > > 程序设计 > Java技术 >

Java入门（六）：数组

2018-06-18 02:52:48来源：未知阅读 ()

数组是一种数据结构，用于存储同一类型值的集合，也可以看做是数据类型一致的一组数据。

一、语法和声明数组

1、语法：数据类型[ ] array = new 数据类型[长度]；

注意：

使用长度创建数组的时候，每个元素都有默认值。

对于int、byt、short、long，其默认值为0；

对于double、float，其默认值为0.0；

对于boolean值，其默认值为false；

对于char，其默认值为编码是0的字符；

对于引用类型（其中包括String），其默认值为null。

2、如果事先已经知道数组的元素，可以直接使用元素初始化数组，但是不需要写数组长度，元素的个数就是数组长度。其次，例如int[ ] a 和int a[ ]两种声明都可用，但是不建议使用后面的写法。

3、如果数据元素不多，并且知道每个元素的值，可以直接使用元素进行初始化。如果元素过多，使用长度创建数组。如果元素没有初始值，使用长度初始化。

　　 /**
     * 数组的声明
     */
    public static void testMethod() {
        // 第一种写法
        int[] array = new int[3];
        // int类型的默认值是0
        System.out.println(array[0]); // 0
        String[] strArray = new String[3];
        // 于引用类型（其中包括String），其默认值为null
        System.out.println(strArray[0]); // null
        // 数组声明的第二种写法
        int[] array2 = {1,2,3};
        System.out.println(array2[0]); // 1
        // 下面这种写法也可以，但是不建议使用，将[]紧跟在数据类型后面，方面理解和区分
        int array3[] = {4,5,6};
        System.out.println(array3[0]); // 4
    }

二、访问数组元素

1、使用数组名[下标序号] 来访问数组元素。

2、数组的 .length 属性，可以获取数组的长度，即数组元素个数。

3、数组下标范围是从0开始，一直到 length-1 。

4、如果超范围访问，会出现运行异常，数组下标越界。下标小于0或者大于等于length，都是超范围。

    /**
     * 数组长度获取，元素访问
     */
    public static void arrayLength() {
        // 获取数组的长度，使用 .length 属性
        int[] array = {1,2,3,4};
        System.out.println(array.length); // 4
        // 数组的长度一经定义，就不能改变，因为其length属性是由final关键字修饰的，不可修改
        //array.length = 5; // The final field array.length cannot be assigned
        // 访问数组的元素，使用 [元素所在下标] , 下标从0开始
        System.out.println(array[0]); // 打印数组第一个元素1
        // 下标越界后，会出现 java.lang.ArrayIndexOutOfBoundsException 的异常
        // System.out.println(array[4]); 
    }

三、数组遍历

利用for循环和for each循环，可以很轻松实现遍历数组元素。

　　 /**
     * 数组遍历
     */
    public static void seeArrayElements() {
        int[] array = {1,2,3,4,5};
        // for循环遍历打印
        for (int i=0; i<array.length; i++) {
            System.out.println(array[i]);
        }
        // for each遍历打印，括号中的第一个参数是元素的数据类型
        // 第二个参数是获取值的局部变量名称（可以随意命名），第三个参数是数组名
        for (int element : array) {
            System.out.println(element);
        }
    }

四、数组拷贝和扩容

1、数组拷贝。

使用java.util.Arrays类中的copyOf( )方法来实现，而Arrays.copyOf( )方法的实现原理是借助System类的arraycopy方法，感兴趣的可以去尝试自己造下轮子，然后和官方的arraycopy方法进行对比。

2、数组扩容。

数组在初始化完成后，其长度是不能修改的，那么想要将一个数组长度变大或者变小，同样可以借助Arrays.copyOf( )方法。无论数组是扩容还是变小，原数组是不会改变的，只是将对象换做了一个新数组。

　　 /**
     * 复制数组，数组扩容，无论数组是扩容还是变小，原数组是不会改变的
     */
    public static void makeArrayCopy() {
        // 复制数组，这里用到的是java.util.Arrays类中的copyOf()方法
        int[] array = {2,4,6};
        int[] newArray = Arrays.copyOf(array, array.length);
        // 判断两个数组是否相等，用到的是Arrays类中的equals()方法
        System.out.println(Arrays.equals(array, newArray)); // true
        // 数组扩容
        int[] addLength = Arrays.copyOf(array, array.length + 1);
        System.out.println(addLength.length); // 4
        for (int e : addLength) {
            System.out.println(e); // 依次打印2 4 6 0
        }
        // 数组变小
        int[] addLength2 = Arrays.copyOf(array, array.length - 1);
        System.out.println(addLength2.length); // 2
        for (int e : addLength2) {
            System.out.println(e); // 依次打印2 4
        }
    }

五、数组排序

对数组的相邻元素进行比较，按照升序或降序规则进行换位，最后得到排序后的数组。

　　 /**
     * 对数组进行升序排序
     */
    public static void sortArrayAsc() {
        // 声明并初始化一个数组
        int[] array = {2, 10, 3, 78, 1, 29, 91, 5};
        System.out.println(Arrays.toString(array));
        for (int i=0; i<array.length-1; i++) {
            for (int j=0; j<array.length-i-1; j++) {
                if (array[j] > array[j+1]) {
                    int k = array[j];
                    array[j] = array[j+1];
                    array[j+1] = k;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
    
    /**
     * 对数组进行降序排序
     */
    public static void sortArrayDesc() {
        // 声明并初始化一个数组
        int[] array = {2, 10, 3, 78, 1, 29, 91, 5};
        // 将数组变为字符串输出
        System.out.println(Arrays.toString(array));
        for (int i=0; i<array.length-1; i++) {
            for (int j=0; j<array.length-i-1; j++) {
                if (array[j] < array[j+1]) {
                    int k = array[j];
                    array[j] = array[j+1];
                    array[j+1] = k;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
    
    /**
     * 利用Arrays.sort()方法进行排序
     */
    public static void utilSort() {
        // 声明并初始化一个数组
        int[] array = {2, 10, 3, 78, 1, 29, 91, 5};
        System.out.println(Arrays.toString(array));
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }

六、二维数组

二维数组，从本质上来讲，还是一维数组，对二维数组的操作其实还是对一维数组的操作。

1、声明。类型[ ][ ] 变量名 = new 类型[ 长度 ][ 长度 ] ;

2、length属性。其长度是第一个[ ]中的长度值。

3、下标也是从0开始，也遵循下标不能越界的规则。

4、其他操作也和一维数组的操作类似。

　　 public static void stateTwoDimArray() {
        // 声明一个二维数组
    　　 int[][] array = new int[2][3];
        // 对其元素赋值
        array[0][0] = 1;
        array[0][1] = 2;
        array[0][2] = 3;
        System.out.println(Arrays.toString(array[0])); // [1, 2, 3]
        System.out.println(Arrays.toString(array[1])); // [0, 0, 0]
        System.out.println(array.length); // 2
        // 声明并初始化一个二维数组
        int[][] array2 = {{1,2},{3,4}};
        System.out.println(Arrays.toString(array2[0])); // [1, 2]
        System.out.println(Arrays.toString(array2[1])); // [3, 4]
        System.out.println(array2.length); //2
    }