JAVA从小白到大神第九章数组

在JAVA中数组的下标由0开始

9.1一维数组

9.1.1数组的声明

例：

int intArray[];

float[] floatArray;

String strArray[];

Date[] dataArray;

9.1.2数组的初始化

声明完成后就要对数组进行初始化，数组初始化的过程就是为数组每一个元素分配内存空间，并为每一个元素提供初始值。初始化之后数组的长度就确定下来不能在变化了。

数组初始化可以分为静态初始化和动态初始化。

1.静态初始化

//声明同时初始化数组

int intArray[] = { 21, 32, 25, 98};

String strArray[] = {"张三"，"李四"，"王五"}；

2.动态初始化

int intArray[];

//动态初始化int数组

int Array = new int[4];

intArray[0] =21;

intArray[1] = 32;

intArray[2] = 56;

9.1.3案例：数组合并

数组长度是不可变的，要想合并两个不同的数组，不能通过在一个数组的基础上追加另一个数组实现，需要创建一个新的数组，新数组的长度为两个数组长度之和。然后再将两个数组的内容导入到新数组中。

package ChapterNine;

public class Arraymerge {
    public static void main(String[] args) {
        //两个待合并数组
        int array1[] = {20, 10, 50, 40, 30 };
        int array2[] = { 1 ,2 ,3 };
        
        //动态初始化数组，设置数组的长度为array1和array2的长度之和
        int array[] = new int[array1.length + array2.length];
        
        //循环添加数组内容
        for(int i = 0;i < array.length; i++) {
            
            if(i<array1.length) {
                array[i] = array1[i];
            } else {
                array[i] = array2[i - array1.length];
            }
        }
        System.out.println("合并后:");
        for (int element : array) {
            System.out.printf("%d " , element);
        }
    }
}
9.2.2二维数组的初始化

1.静态初始化

例：

int Array[][] = { { 1, 2, 3 }, {11, 12, 13}, { 21, 22, 23}, {31, 32, 33} };

2.动态初始化

new 元素数据类型[高维数组长度] [低维数组长度]；

int [] [] intArray = new int [4] [3];

package ChapterNine;

public class TwoDimensionalArray {
    public static void main (String[] args) {
        //静态初始化二维数组
        int [] [] intArray = {
                { 1, 2, 3},
                { 11, 12, 13},
                { 21, 22, 23},
                { 31, 32, 33}
        };
        
        //动态初始化二维数组
        double[] [] doubleArray = new double[4] [3];
        
        //计算数组intArray元素的平方根，结果保存到doubleArray
        for(int i = 0; i < intArray.length ; i++) {
            for(int j = 0;j < intArray[i].length; j++) {
                //计算平方根
                doubleArray[i] [j] = Math.sqrt(intArray[i] [j]);
            }
        }
        
        //打印数组doubleArray
        for(int i = 0; i < doubleArray.length; i++) {
            for(int j = 0; j<doubleArray[i].length; j++) {
                System.out.printf("[%d] [%d] = %f", i ,j , doubleArray[i] [j]);
                System.out.print('\t');
            }
            System.out.println();
        }
                
}
}

9.2.3不规则数组

规则的4*3数组有十二个元素，不规则的数组就不一定了

例如：

int intArray[] [] = { { 1, 2 }, { 11 }, {21, 22, 23 }, { 31, 32, 33} };

动态初始化比较麻烦

int intArray[] [] = new int[4] [];

//逐一初始化低维数组

int array[0] = new int [2];

int array[1] = new int [1];

int array[2] = new int [3];

int array[3] = new int [3];

例子：

package ChapterNine;

public class JaggedArray {
    public static void main(String[] args) {
        int intArray[] [] = new int[4] [];

        //逐一初始化低维数组

        intArray[0] = new int [2];
        intArray[1] = new int [1];
        intArray[2] = new int [3];
        intArray[3] = new int [3];
        
        //for循环遍历
        for (int i = 0;i < intArray.length; i++) {
            for (int j = 0; j < intArray[i].length; j++) {
                intArray[i][j] = i + j;
            }
        }
        
        //增强for循环遍历
        for(int[] row : intArray) {
            for(int column : row) {
                System.out.print(column);
                //在元素之间添加制表符
                System.out.print('\t');
                
            }
            //一行元素打印完成后换行
            System.out.println();
        }
         // System.out.println(intArray[0] [2]); //发生运行期错误，因为[0][2]不存在
    }
}