Java学习笔记(No.11)

最新推荐文章于 2024-02-04 08:52:23 发布

学山学海

最新推荐文章于 2024-02-04 08:52:23 发布

阅读量135

点赞数

分类专栏：学习笔记文章标签： java

本文链接：https://blog.csdn.net/baidu_28055785/article/details/117750727

版权

学习笔记专栏收录该内容

25 篇文章 0 订阅

订阅专栏

Java数组详解(No.11)

1、数组的含义(The Meaning Of Array)

数组是相同类型数据的有序集合。其描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成；其中，每一个数据称作一个数组元素，每个数组元素都是通过一个下标(索引)来访问，且数组下标(索引)从0开始。

2、数组的声明与创建(Declaration And Creation Of Array)

首先必须声明数组变量，才能在程序中使用数组。

2.1、语法格式(Grammatical Format)

2.1.1、方式一(Mode One)

将数组的声明与创建分开使用。

2.1.1.1、数组的声明语法格式为：

“数据类型[] 数组变量名称;//首选(推荐使用)

或者

数据类型数组变量名称[];//效果一样，非首选(主要是为了兼容C/C++)”。
2.1.1.2、数组的创建语法格式为：

“数组变量名称 = new 数据类型[数组长度]。

2.1.2、方式二(Mode Two)

将数组的声明与创建合并使用。其语法格式为：

“数据类型[] 数组变量名称 = new 数据类型[数组长度];//首选方法(推荐使用)

或者

数据类型数组变量名称[] = new 数据类型[数组长度];//效果一样，非首选方法(主要是为了兼容C/C++)”。

2.2、示例(Example)

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
public class ArrayDeclarationAndCreation {
    public static void main(String[] args) {
//        int[] arrayInt1;//声明数组(方式一)<首选>
//        int arrayInt2[];//声明数组(方式二)<非首选>
//        arrayInt1=new int[10];//创建数组(方式一)<首选>
//        arrayInt2=new int[10];//创建数组(方式二)<非首选>
//        int[] array1=new int[10];//声明与创建数组(方式一)<首选>
//        int array2[]=new int[10];//声明与创建数组(方式二)<非首选>
//        int[] array=new int[]{1,2,3,4,5,6,7,8,9,10};//声明与创建及初始化数组(方式一)<首选>
        int[] array = new int[10];//声明与创建数组(方式一)<首选>
        //使用For循环遍历数组初始化各数组元素
        for (int i = 0; i < array.length; i++) {
            array[i] = i + 1;
        }
        //使用For循环遍历数组输出数组元素
        System.out.println("使用For循环遍历数组输出数组元素:");
        System.out.println("===========================");
        for (int i = 0; i < array.length; i++) {
            System.out.println("数组元素array[" + i + "]=" + array[i]);
        }
        System.out.println("===========================");
        //使用增强型For循环遍历数组输出数组元素
        System.out.println("使用增强型For循环遍历数组输出数组元素：");
        System.out.println("===========================");
        int count=0;
        for (int ef:array) {
            System.out.println("数组元素array[" + (count++) + "]=" + ef);
        }
        System.out.println("===========================");
    }
}

其运行结果，如下图所示。

数组的声明与创建运行结果

3、内存分析及三种初始化(Memory Analysis And Three Kinds Of Initialization)

3.1、内存分析(Memory Analysis)

3.1.1、Java内存原理(Java Memory Principle)

其如下图所示。

内存分析

3.1.2、写代码及画图分析Java内存(Write Code And Draw Diagram To Analyze Java Memory)

其如下图所示。

写代码及画图分析Java内存

3.2、三种初始化(Three Kinds Of Initialization)

3.2.1、数组默认初始化(Array Default Initialization)

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也按照实例变量同样的方式被隐式初始化，数组默认初始化如以下代码所示。

//数组默认初始化,所有数组元素值为0
int[] array1 = new int[1];

3.2.2、数组动态初始化(Array Dynamic Initialization)

数组动态初始化包含“数组默认初始化”，如以下代码所示。

//数组动态初始化包含“数组默认初始化”
int[] array2 = new int[2];//数组默认初始化,所有数组元素值为0
array2[0]=1;
array2[1]=2;

3.2.3、数组静态初始化(Array Static Initialization)

数组静态初始化如以下代码所示。

//数组静态初始化,所有数组元素值在初始化时必须指定
int[] array3={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)};

3.2.4、示例(Example)

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
public class InitializationArray {
    public static void main(String[] args) {
        //数组默认初始化,所有数组元素值为0
        int[] array1 = new int[1];
		//ArrayDeclarationAndCreation[] aDACs= {new ArrayDeclarationAndCreation(),new ArrayDeclarationAndCreation()};//引用类型数组
        //使用For循环输出默认初始化数组元素
        System.out.println("使用For循环输出默认初始化数组元素：");
        System.out.println("===========================");
        for (int i = 0; i < array1.length; i++) {
            System.out.println("默认初始化数组元素array1["+i+"]="+array1[i]);
        }
        System.out.println("===========================");
        //数组动态初始化包含“数组默认初始化”
        int[] array２ = new int[2];//数组默认初始化,所有数组元素值为0
        //使用For循环遍历数组动态初始化各数组元素
        for (int i = 0; i < array２.length; i++) {
            array２[i] = i + 1;
        }
        //使用For循环输出动态初始化数组元素
        System.out.println("使用For循环输出动态初始化数组元素：");
        System.out.println("===========================");
        for (int i = 0; i < array２.length; i++) {
            System.out.println("动态初始化数组元素array２["+i+"]="+array２[i]);
        }
        System.out.println("===========================");
        //数组静态初始化
        int[] array3 = {1,2,3};
        //使用For循环输出静态初始化数组元素
        System.out.println("使用For循环输出静态初始化数组元素：");
        System.out.println("===========================");
        for (int i = 0; i < array3.length; i++) {
            System.out.println("静态初始化数组元素array3["+i+"]="+array3[i]);
        }
        System.out.println("===========================");
    }
}

其运行结果，如下图所示。

数组三种初始化运行结果

4、数组基本特点(Basic Characteristics Of Array)

4.1、数组长度是确定的。数组一旦被创建，它的大小是不可以改变的。
4.2、数组元素必须是相同类型，不允许出现混合类型。
4.3、数组元素可以是任何数据类型，包括基本类型和引用类型。
4.4、数组变量属于引用类型，数组也可以看成是对象，数组中每个元素相当于该对象成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身是在堆中的。

5、数组下标(索引)越界及小结(Array Subscript(Index) Out Of Bounds And Summary)

5.1、数组下标(索引)越界

数组下标(索引)的合法边界区间：“0~(数组长度-1)”，若越界就会触发系统报错，即，“数组索引越界异常(ArrayIndexOutOfBoundsException)”。

5.2、小结

5.2.1、数组是相同数据类型(数据类型可以为任意类型)的有序集合。
5.2.2、数组也是对象。数组元素相当于对象的成员变量。
5.2.3、数组长度是确定的，不可改变的。若越界，则触发“数组下标(索引)越界异常”。

6、数组的应用(The Application Of Array)

6.1、普通For循环遍历数组

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
public class ApplicationArray1 {
    public static void main(String[] args) {
        int[] array1 = {1, 3, 9, 7, 5};
        //使用For循环输出数组所有元素
        System.out.println("=========================");
        for (int i = 0; i < array1.length; i++) {
            System.out.println("(For循环)输出数组元素array1[" + i + "]=" + array1[i]);
        }
        System.out.println("=========================");
        //使用For循环计算数组所有元素之和
        int sum = 0;
        System.out.println("=========================");
        for (int i = 0; i < array1.length; i++) {
            sum += array1[i];
        }
        System.out.println("(For循环)数组所有元素之和：" + sum);
        System.out.println("=========================");
        //使用For循环计算数组所有元素中最大值
        int maxNum = array1[0];
        System.out.println("=========================");
        for (int i = 1; i < array1.length; i++) {
            if (maxNum < array1[i]) {
                maxNum = array1[i];
            }
        }
        System.out.println("(For循环)数组所有元素中最大值：" + maxNum);
        System.out.println("=========================");
    }
}

其运行结果，如下图所示。

普通For循环遍历数组运行结果

6.2、增强型For循环(即，For-Each循环)遍历数组

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
public class ApplicationArray2 {
    public static void main(String[] args) {
        int[] array1 = {1, 3, 9, 7, 5};
        //使用增强型For循环输出数组所有元素
        int count = 0;
        System.out.println("=========================");
        for (int arr1 : array1) {//JDK1.5新特性，没有下标概念
            System.out.println("(增强型For循环)输出数组元素array[" + (count++) + "]=" + arr1);
        }
        System.out.println("=========================");
        //使用增强型For循环计算数组所有元素之和
        int sum = 0;
        System.out.println("=========================");
        for (int arr2 : array1) {//JDK1.5新特性，没有下标概念
            sum += arr2;
        }
        System.out.println("(增强型For循环)数组所有元素之和：" + sum);
        System.out.println("=========================");
        //使用增强型For循环计算数组所有元素中最大值
        int maxNum = array1[0];
        System.out.println("=========================");
        for (int arr3 : array1) {//JDK1.5新特性，没有下标概念
            if (maxNum < arr3) {
                maxNum = arr3;
            }
        }
        System.out.println("(增强型For循环)数组所有元素中最大值：" + maxNum);
        System.out.println("=========================");
    }
}

其运行结果，如下图所示。

增强型For循环遍历数组运行结果

6.3、数组作为方法入参

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
public class ApplicationArray3 {
    public static void main(String[] args) {
        int[] array = {1, 3, 9, 7, 5};
        System.out.println("调用“打印数组元素”方法输出打印数组元素：");
        printArray(array);//调用“打印数组元素”方法
    }
    //打印数组元素
    public static void printArray(int[] arrayInt){
//        //方法一：使用普通For遍历输出打印数组元素
//        for (int i = 0; i < arrayInt.length; i++) {
//            System.out.println(arrayInt[i]);
//        }
        //方法二：使用增强型For遍历输出打印数组元素
        for (int aI : arrayInt) {
            System.out.println(aI);
        }
    }
}

其运行结果，如下图所示。

数组作为方法入参运行结果

6.4、数组作为返回值

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
public class ApplicationArray4 {
    public static void main(String[] args) {
        int[] array = {1, 3, 9, 7, 5};
        System.out.println("调用“反转数组”方法之前调用“打印数组元素”方法输出打印数组元素：");
        System.out.println("===================================================");
        printArray(array);//调用“打印数组元素”方法
        System.out.println("===================================================");
        int[] reverseArrays = reverseArray(array);//调用“反转数组”方法
        System.out.println("调用“反转数组”方法之后调用“打印数组元素”方法输出打印数组元素：");
        System.out.println("===================================================");
        printArray(reverseArrays);//调用“打印数组元素”方法
        System.out.println("===================================================");
    }
    //打印数组元素
    public static void printArray(int[] arrayInt) {
        //使用增强型For遍历输出打印数组元素
        for (int aI : arrayInt) {
            System.out.println(aI);
        }
    }
    //反转数组
    public static int[] reverseArray(int[] arrayInt) {
//        //方法一
//        int[] result = new int[arrayInt.length];
//        for (int i = 0; i <= result.length / 2; i++) {//反转操作
//            if (i != result.length - 1 - i) {
//                result[i] = arrayInt[result.length - 1 - i];
//                result[result.length - 1 - i] = arrayInt[i];
//            }else{
//                result[i] = arrayInt[i];
//            }
//        }
//        return result;
        //方法二
        int[] result = new int[arrayInt.length];
        for (int i = 0, j = result.length - 1; i < result.length; i++, j--) {//反转操作
            result[j] = arrayInt[i];
        }
        return result;
    }
}

其运行结果，如下图所示。

数组作为返回值运行结果

7、二维数组(Two-Dimensional Array)

多维数组(Multi-Dimensional Array)可以看成是数组的数组。如“二维数组(Two-Dimensional Array)”就是一个特殊的一维数组(One-Dimensional Array)，其每一个元素都是一个一维数组。

7.1、二维数组的声明与创建(Declaration And Creation of Two-Dimensional Array)

7.1.1、方式一(Mode One)

将二维数组的声明与创建分开使用。

7.1.1.1、二维数组的声明语法格式为：

“数据类型[][] 二维数组变量名称;//首选(推荐使用)

或者

数据类型二维数组变量名称[][];//效果一样，非首选(主要是为了兼容C/C++)”。
7.1.1.2、二维数组的创建语法格式为：

“二维数组变量名称 = new 数据类型[数组一维长度][数组二维长度]。

7.1.2、方式二(Mode Two)

将二维数组的声明与创建合并使用。其语法格式为：

“数据类型[][] 二维数组变量名称 = new 数据类型[数组一维长度][数组二维长度];//首选方法(推荐使用)

或者

数据类型二维数组变量名称[][] = new 数据类型[数组一维长度][数组二维长度];//效果一样，非首选方法(主要是为了兼容C/C++)”。

7.2、二维数组的应用(The Application Of Two-Dimensional Array)

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
public class ApplicationTwoDimensionalArray {
    public static void main(String[] args) {
        /*
        1,2   arrayTwoDimensional[0]    arrayTwoDimensional[0][0]=1    arrayTwoDimensional[0][1]=2
        3,4   arrayTwoDimensional[1]    arrayTwoDimensional[1][0]=3    arrayTwoDimensional[1][1]=4
        5,6   arrayTwoDimensional[2]    arrayTwoDimensional[2][0]=5    arrayTwoDimensional[2][1]=6
        7,8   arrayTwoDimensional[3]    arrayTwoDimensional[3][0]=7    arrayTwoDimensional[3][1]=8
        9,10  arrayTwoDimensional[4]    arrayTwoDimensional[4][0]=9    arrayTwoDimensional[4][1]=10
        */
        int[][] arrayTwoDimensional = {{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}};
        System.out.println("使用普通For循环遍历输出二维数组：");
        System.out.println("====================================");
        for (int i = 0; i < arrayTwoDimensional.length; i++) {
            for (int j = 0; j < arrayTwoDimensional[i].length; j++) {
                System.out.print("二维数组元素arrayTwoDimensional[" + i + "][" + j + "]=" + arrayTwoDimensional[i][j] + "\t");
            }
            System.out.println();//换行
        }
        System.out.println("====================================");
    }
}

其运行结果，如下图所示。

二维数组的应用运行结果

8、Arrays类讲解(Explanation Of Arrays Class)

由于数组对象本身并没有什么方法可以使用，但 API中提供了一个工具类Arrays(java.util.Arrays)让我们使用，从而可以对数组对象进行一些基本的操作。且Arrays类中的方法都是static修饰的静态方法，使用时可直接用类名调用(建议使用)，也可用对象调用(不建议使用)。

8.1、Arrays类的常用功能(The Application Of Array Class)

8.1.1、给数组赋值：通过fill方法。
8.1.2、对数组排序(升序)：通过sort方法。
8.1.3、比较数组：通过equals方法比较2个数组中的元素值是否相等。
8.1.4、查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作，即，查找指定数组元素在查找数组中的下标(索引)，其中需特别的是查找前一定要先升序排序好才能准确查找出来。

8.2、Arrays类的应用(The Application Of Array Class)

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
import java.util.Arrays;
public class ArrayClass {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 9, 7, 5, 8, 4, 6, 0};
        System.out.println("调用Arrays类的“sort”方法前，调用Arrays类的“toString”方法输出打印数组元素：");
        System.out.println("=========================================");
        System.out.println(Arrays.toString(arr));//调用Arrays类的“toString”方法输出打印数组元素
        System.out.println("=========================================");
        Arrays.fill(arr, 7, 10, 1);//调用Arrays类的“fill”方法给数组指定下标(索引)区间赋值
        System.out.println("调用Arrays类的“fill”方法后，调用Arrays类的“toString”方法输出打印数组元素：");
        System.out.println("=========================================");
        System.out.println(Arrays.toString(arr));//调用Arrays类的“toString”方法输出打印数组元素
        System.out.println("=========================================");
        System.out.println("调用Arrays类的“equals”方法比较2个数组中的元素值是否相等：");
        System.out.println("=========================================");
        System.out.println("数组arr与数组arr相等的结果为：" + Arrays.equals(arr, arr));//调用Arrays类的“equals”方法比较2个数组中的元素值是否相等
        System.out.println("=========================================");
        Arrays.sort(arr);//调用Arrays类的“sort”方法按升序对数组元素排序
        System.out.println("调用Arrays类的“sort”方法后，调用Arrays类的“toString”方法输出打印数组元素：");
        System.out.println("=========================================");
        System.out.println(Arrays.toString(arr));//调用Arrays类的“toString”方法输出打印数组元素
        System.out.println("=========================================");
        System.out.println("调用Arrays类的“binarySearch”方法查找指定数组元素在查找数组中的下标(索引)：");
        System.out.println("=========================================");
        System.out.println("指定数组元素在查找数组中的下标(索引)为：" + Arrays.binarySearch(arr, 1));//调用Arrays类的“binarySearch”方法查找指定数组元素在查找数组中的下标(索引)
        System.out.println("=========================================");
    }
}

其运行结果，如下图所示。

Arrays类的应用运行结果

8.3、注意事项(Matters Needing Attention)

下载并查看JDK帮助文档。

9、冒泡排序算法(Bubble Sort Algorithm)

总共分为八大排序算法，其中冒泡排序算法是最为出名的排序算法之一。

冒泡排序算法是双层嵌套循环，外层冒泡轮数，内层依次比较，且其算法最好的时间复杂度为"O(n)"，最坏时间复杂度为“O(n²)”，总的平均时间复杂度为“O(n²)”。

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
import java.util.Arrays;
public class BubbleSortAlgorithm {
    public static void main(String[] args) {
        int[] array1 = {1, 3, 5, 9, 7, 8, 6, 2, 4};
        System.out.println("使用冒泡排序算法之前输出数组元素：");
        System.out.println("============================");
        System.out.println(Arrays.toString(array1));//调用Arrays类的“toString”方法输出打印数组元素
        System.out.println("============================");
        int[] arrayBubbleSort = bubbleSortArray(array1);//调用"冒泡排序算法"方法
        System.out.println("使用冒泡排序算法之后输出数组元素：");
        System.out.println("============================");
        System.out.println(Arrays.toString(arrayBubbleSort));//调用Arrays类的“toString”方法输出打印数组元素
        System.out.println("============================");
    }
    /*冒泡排序算法原理：
    1、比较数组中2个相邻的元素，若第1个元素大于第2个元素，则交换2个元素之间的位置
    2、每一次比较都会产生1个最大或最小的元素
    3、每比较完一轮后，下一轮都可以少一次排序
    4、依次循环，直至循环结束即可*/
    //冒泡排序算法
    public static int[] bubbleSortArray(int[] array) {
        int temp = 0;//临时中间变量
        //外层循环，判断比较排序的次数
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = false;//通过标记flag减少无意义的比较排序次数
            //内层循环，比较相邻2个数组元素，若第1个元素大于第2个元素，则交换2个元素之间的位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;//有比较交换2个元素之间的位置
                }
            }
            if (flag == false) {
                break;//若当前比较排序时，未交换2个元素之间的位置，则比较排序完成，直接退出即可
            }
        }
        return array;
    }
}

其运行结果，如下图所示。

冒泡排序算法运行结果

10、稀疏数组(Sparse Array)

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组，如下图所示。

原始数组与稀疏数组示意图

10.1、稀疏数组的处理方式(Process Mode Of Sparse Array)

10.1.1、记录数组一共有几行几列，有多少个不同值。
10.1.2、把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小数组的规模。

10.2、稀疏数组的生成与还原(Generation And Restoration Of Sparse Array)

比如需求：“编写五子棋游戏中，有存盘退出和续接上盘的功能”，如下图所示。

五子棋游戏棋盘

其示例，如以下代码所示。

package com.xueshanxuehai.Array;
public class SparseArray {
    public static void main(String[] args) {
        //1、创建1个11行11列的二维数组：其中“0”代表“无棋子”；“1”代表“黑棋”；“2”代表“白棋”；
        int[][] arraySource = new int[11][11];
        arraySource[1][2] = 1;//已下“黑棋”
        arraySource[2][3] = 2;//已下“白棋”
        //1.1、输出原始数组
        System.out.println("输出原始的数组：");
//        System.out.println("============================================");
        for (int[] ints : arraySource) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();//换行
        }
//        System.out.println("============================================");
        //2、生成稀疏数组(即，将原始数组转换为稀疏数组保存)
        //2.1、获取原始数组有效值的个数
        int count1 = 0;
        for (int i = 0; i < arraySource.length; i++) {
            for (int j = 0; j < arraySource[i].length; j++) {
                if (arraySource[i][j] != 0) {
                    count1++;
                }
            }
        }
        System.out.println("原始数组有效值个数：" + count1);
        //2.2、创建１个稀疏数组
        int[][] arraySparse = new int[count1 + 1][3];
        arraySparse[0][0] = arraySource[0].length;
        arraySparse[0][1] = arraySource[1].length;
        arraySparse[0][2] = count1;
        //2.3、遍历原始数组，将非零的值存放到稀疏数组
        int count2 = 0;
        for (int i = 0; i < arraySource.length; i++) {
            for (int j = 0; j < arraySource[i].length; j++) {
                if (arraySource[i][j] != 0) {
                    count2++;
                    arraySparse[count2][0] = i;
                    arraySparse[count2][1] = j;
                    arraySparse[count2][2] = arraySource[i][j];
                }
            }
        }
        //2.4、输出生成的稀疏数组
        System.out.println("输出生成的稀疏数组：");
//        System.out.println("============================================");
        for (int i = 0; i < arraySparse.length; i++) {
            for (int j = 0; j < arraySparse[i].length; j++) {
                System.out.print(arraySparse[i][j] + "\t");
            }
            System.out.println();//换行
        }
//        System.out.println("============================================");
        //3、还原稀疏数组
        //3.1、读取稀疏数组
        int[][] arrayRestore = new int[arraySparse[0][0]][arraySparse[0][1]];
        //3.2、还原稀疏数组中有效值的数组元素
        for (int i = 1; i < arraySparse.length; i++) {
            arrayRestore[arraySparse[i][0]][arraySparse[i][1]] = arraySparse[i][2];
        }
        //3.3、输出还原的稀疏数组
        System.out.println("输出还原的稀疏数组：");
//        System.out.println("============================================");
        for (int[] ints : arrayRestore) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();//换行
        }
//        System.out.println("============================================");
    }
}

其运行结果，如下图所示。

稀疏数组的生成与还原运行结果

参考资料(Reference Data)：冒泡排序

学习网站地址(即"学习网址",Learning Website Address)：Java数组详解

学山学海

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记(No.11)

Java数组详解(No.11)1、数组的含义(The Meaning Of Array) 数组是相同类型数据的有序集合。其描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成；其中，每一个数据称作一个数组元素，每个数组元素都是通过一个下标(索引)来访问，且数组下标(索引)从0开始。2、数组的声明与创建(Declaration And Creation Of Array) 首先必须声明数组变量，才能在程序中使用数组。2.1、语法格式(Grammatical Format)2.1.1
复制链接

扫一扫