Java学习第二课 - 数组

                                                                         /*数组*/
                //1 数组

                //C中的定义数组的方式，但仍有不同，在C中除非直接初始化，否则是不允许[]为空的。
                //另外C中为数组分配空间是在栈上的。系统负责根据作用域自动释放，而Java中如下
                //定义的数组只是定义了一个数组名，还没有分配空间，是不能直接引用的。否则会出现
                //错误。
                int Carray[];
                //为数组分配空间并初始化
                Carray = new int[] {1,2,3};
                //java 定义数组的方式，很独特。将[]与数组名分开了
                int[] Jarray;
             Jarray = new int[100];
             //C 方式输出数组的内容
                for(int i = 0; i < Carray.length; ++i)
                {
                        System.out.println(Carray[i]);
                }
             //Java 特有的数组数组内容的方式，这种方式有一个缺点，即不能引用数组的每个值。
             //这是真的吗？我们后面会做个测试。
             for(int h : Carray)
             {
                    System.out.println(h);
             }
             //为什么上面的数组方式无法引用每个值呢。h不是吗？我们做个测试。下面的输出结果为
             //1,2,3说明我们还是可以应用的。
             for(int h : Carray)
             {
                     int text = h;
                    System.out.println(text);
             }

             //我们再研究下数组的初始化工作。
             int[] Array = new int[12]; //定义一个数组并申请空间。
             int[] Too; //定义一个数组不申请空间
            //下面两种初始化都无法进行。
            // Array = {1,2,3};//初始化数组
            // Too = {4,5,6};

             Array = new int[] {6,6,6};
             //Too 和 Array引用同一数组
             Too = Array;
             for(int h : Too)
             {
                     System.out.println(h);
             }

             //重新申请
             Too = new int[] {8,8,8};
             for(int h : Too)
             {
                     System.out.println(h);
             }

             //将Array的内容拷贝到新数组Too中
             Too = Arrays.copyOf(Array,Array.length);
             for(int h : Too)
             {
                     System.out.println(h);
             }

             int[] Two = {9,9,9};
             for(int h : Two)
             {
                     System.out.println(h);
             }

             //2 多维数组
             //其实多维数组并不是什么新东西，只是数组的数组罢了。C中也可以这么理解.
             //定义一个多维数组，目前没有申请空间，不可访问。
             int[][] Darray;
             //定义数组并申请空间
             int[][] DAarry = new int[10][20];

             int[][] EAarry =
             {
                     {3,3,3},
                     {4,5,6}
             };

             System.out.println(Arrays.deepToString(EAarry));
             //C方式
             for (int i = 0; i < EAarry.length; ++i)
             {
                     for (int j = 0; j < EAarry[i].length; ++j)
                     {
                             System.out.println(EAarry[i][j]);
                     }
             }
            //Java方式
             for (int[] row : EAarry)
             {
                     for (int h : row)
                     {
                             System.out.println(h);
                     }

             }

            //3 不规则数组
            // 其实不规则数组和多维数组是一样的，只不过是它的每行列数的不同，有些特别，所以
            //单独把它拉出来说说。

             //构建一个不规则数组，并给他初始化
             int[][] MyArray = new int[10][];
             for (int i = 0; i < 10; ++i)
             {
                     MyArray[i] = new int[i];
                     for (int j = 0; j < i; ++j)
                     {
                            MyArray[i][j] = j;
                     }
             }

             //输出该不规则数组，输出结果为：
             //0
             //0 1
             //0 1 2
             //0 1 2 3
             //0 1 2 3 4
             //0 1 2 3 4 5
             //0 1 2 3 4 5 6
             //0 1 2 3 4 5 6 7
             //0 1 2 3 4 5 6 7 8
             for (int[] row : MyArray)
             {
                     for (int h : row)
                     {
                             System.out.print(h + " ");
                     }
                     System.out.println();
             }

             //4 Java中的数组与C\C++中的区别

             //① 数组

             // Java 中的数组
             // int[] JavaOne;
             // JavaOne = new int[10];
            //    int[] JavaOne = new int[10];
            // 等同于 C\C++中的;
            // int * Cone;
            // Cone = new int[10];
            //int *Cone = new int[10]; 不等同于 int Cone[10];

             //② 多维数组

             // Java 中的数组
             //int[][] JavaTwo;
             //JavaTwo = new int[10][20];
             //int[][] JavaTwo = new int[10][20];
             //等同于C\C++中的：
             //int **Ctwo;
             //Ctwo = new int*[10];    for(int i = 0; i < 10; ++i) Ctwo[i] = new int[20];