黑马程序员 一步一步往上爬 学习毕老师java视频的第03,04天

 

---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------

毕向东 Java基础视频教程03天 01 语句（while）

１.   while(x<3)

{}里面是循环体，执行完循环体，再进入条件表达式进行判断

２.   ctrl+c强制结束命令行

３.   单独地x++;和++x；是一样的，不存在赋值，只给自己自增1.

４.   一般x=x+2等价于x+=2.

 

 

 

毕向东 Java基础视频教程03天 02 语句（while）

１.   do while先无条件执行一次，在判断，while先判断在执行，do while无论条件是否满足至少执行一次。

２.   语句结束有两种方式，要么后面跟;  要么是} 。do while后面有;  while后面无;

３.   Int y=3

While(y<5);

{

……..

}

由于while后面给加了;, 判断完之后没有循环体，计算机会继续判断，满足条件，再继续判断，一直卡在这循环下去，直到崩溃。

 

 

 

毕向东 Java基础视频教程03天 03 语句（for）

１.   for(初始化表达式；条件表达式；循环后的操作表达式)

{

           循环体/执行语句

}

 

 

 

 

毕向东 Java基础视频教程03天 04 语句（for和while的区别）

１.   for中定义的x,在离开for循环之后所开辟的内存就消失了。（变量的作用域），而while的初始化动作是在while之前，循环之后仍存在。

２.   如果变量仅仅用于控制循环次数作为循环增量存在，用for语句，节省内存。需要定义循环增量用for更合适。

３.   但凡有语句要被反复执行很多次就可以考虑循环结构。

 

 

 

毕向东 Java基础视频教程03天 05 语句（循环语句的其他特点）

1.for(初始化表达式；条件表达式；循环后的操作表达式)

  只要中间的表达式可以判断trueor false就行，不一定非要第一个是初始化，第三个自增。甚至可以for( ;x<3; )

２.   一个表达式内可用逗号连接多个内容

３.   For语句的最简单表达形式

For( ; ; ){}  不写条件表达式默认就是true

 

While(true){}

 

 

 

毕向东 Java基础视频教程03天 06 语句（for语句练习 累加&计数器）

１.   sum+=x等价于sum=sum+x;累加思想，对x值进行累加

２.   求1-100之间的7的倍数即个数

思路：通过循环对1-100之间的数进行遍历

      在遍历的过程中，进行判断，若是7的倍数（x%7==0），就打印

      建立自增变量记录个数

３.   累加思想：通过变量记录循环之后操作之后的结果

４.   自增一x=x+1用x++; x自增二=x+2用x+=2

 

 

 

 

毕向东 Java基础视频教程03天 07 语句（for嵌套）

１.   循环嵌套：

２.   System.out.println();只有一个功能：换行

３.   对于打印长方形，外循环控制行数，内循环控制每一行的列数

４.   有行有列用嵌套循环，

５.   分别用新变量和不用新变量打印上图

用新变量：

行数是固定的五行，用外循环的循环次数控制行数

但是每一行的列数不同，需要每次进行内循环时改变内循环的次数

改变方法：要么改变初值，要变改变终值来控制循环次数区间

采用改变终值如下：int z=5;

           for(int x=0;x<=5;x++)

           {

                   

                    for(int y=0;y<=z;y++)

                             System.out.print("*");

                    System.out.println();

                    z--;

不用新变量，借用已知变量改变内循环的初值，进而改变内循环的次数

for(int x=0;x<=5;x++)

           {

                    for(int y=x;y<=5;y++)

                             System.out.print("*");

                    System.out.println();

 

 

 

 

 

毕向东 Java基础视频教程03天 08 语句（for嵌套练习）

１.   输出上图的三角时，尖朝下改变前面，尖朝上改变后面。

２.   打印该图：

确保行数，确保每一行的列数，确保每一行开始的数和递增就OK了

分析；这是由数字组成的图形，建议x,y初值都为1，这样x.y值就对应行列数。

      Y初值是1，还可以用于每行第一个输出的值是1，达到两用。 后面y++,实现同一行的数不断递增。

      尖朝上该后面（条件表达式）

      第一行有1个，第二行有两个，第x行有x个（只有在x初值是1时才可这么说，x初值是0，就一行行去看），所以保证内循环次数为x

for(int x=1;x<=5;x++)

           {

                    for(int y=1;y<=x;y++)

３.   For( ；y<x+1；)等价于( ；y<=x；)因为都是把相对于y<x区间扩大了1

 

 

 

毕向东 Java基础视频教程03天 09语句（九九乘法表）

１.   九九乘法表中，只需要关注两个乘数，

而被乘数都是行数，故for(x=1;x<=9;x++)用x来表示行数。

只需要关注乘数，每行乘数都是从1开始递增，故for(y=1; ;y++)

关注每一行乘数个数，第一行1一个，。。。第x行x个，故for(y<=x)

for(int x=1;x<=9;x++)

           {

                    for(int y=1;y<=x;y++)

                             System.out.print(y+"*"+x+"="+y*x+"\t");

                    System.out.println();

 

 

 

毕向东 Java基础视频教程03天 10语句（break continue）

１.   break作用的语句：选择结构if switch+循环结构（用于跳出当前循环）

２.   可用标号给循环起名，m:for(), 这样就可以跳出指定循环 break m;

３.   Continue:自能作用于当前循环结构：结束本次循环执行下次循环 break m;

 

 

毕向东 Java基础视频教程03天 11语句（练习）

１.   for循环控制区间时，改前改后都一样，如for(y=x;y<4;y++)

等价于for(y=x+1;y<5;y++)区间都为4-x，在不利用y的具体值时效果一样

２.   输出等腰三角形：

观察此图星状和空格可以把改图分解为一个有空格组成的尖儿朝下直角和一个有星状组成的尖儿朝上直角（星状图形的原型，去掉所有星状中的空格，搞定原型再少变化就可）

步骤：外循环控制行数

     For(int x=0;x<5;x++)

      外循环内包含两个内循环

           内1：控制空格直角

        For(int y=x;y<;y++)(每一行空格的个数通过循环区间的两头控制，习惯性改前面时y=x,然后确定后面的常量)，分析前两行得到y<4

           内2：控制星状直角

           For(int z=0;z<(x+1);z++)

           习惯等价于

           For(int z=0;z<=x;z++)

核心代码如下：

for(int x=0;x<5;x++)                                                

           {

                    for(int y=x;y<4;y++)

                             System.out.print(" ");

                    for(int z=0;z<=x;z++)

                             System.out.print("* ");

                             System.out.println();

 

 

 

 

毕向东 Java基础视频教程03天 12函数（概述）

１.   函数：定义在类中的具有特定功能的一段独立小程序，函数=方法

２.   Java中对功能的定义是通过函数实现的

３.   函数格式：

修饰符 返回值类型 函数名（参数类型 形参1，参数类型 形参2,……）

{

           执行语句；

           Return 返回值；

}

区别形参和实参：形参是变量用于接收调用函数时传递给参数的值

                实参就是这传递给函数的具体地值，是常量

返回值：将函数运算的结果返回给调用者

４.   函数的出现提高了代码和功能的复用性

５.   当函数运算之后没有具体的返回值时，用关键字void来标示。当返回值类型是void时，return可以不写，也可以写return;处于格式的要求，不写的话系统会自己加上。

６.   函数内部不能定义函数，没有谁包含谁，只能调用函数。函数只要放在类里就行，放上放下都行。

 

 

 

 

毕向东 Java基础视频教程03天 13函数（应用）

１.   在定义函数之前要考虑两个问题，第一功能的结果，用来明确返回值的类型，第二,是否有位置内容参与运算，用来明确参数类型

２.   简化ifelse语句：三元运算符，在ifelse语句执行完有结果时，可以用三元运算符简化，因为三元运算符运算玩必须有结果。

３.   a==b,注意==和+一样都是运算符，不过==是比较运算符，+是求和运算符，a+b运算完有一个结果，而a==b运算完也有一个结果，只不过它的运算结果为boolean数据类型（true false）。

４.   定义一个函数，比较两个数是否相等。

５.   当返回值是boolean时就要考虑通过比较运算符的结果对代码进行简化。

６.   X==y不是读作x等于y，而是x是否等于y,等于运算结果为true.

 

 

 

毕向东 Java基础视频教程03天 14函数（练习）

１.   自定义函数可以没有返回值，可以在运算过程中没有位置变量，就把参数位置空着就行。

２.   九九乘法表中1*2=3，在输出时第一个*是字符串类型，不能做位运算符，否则显示不了1*2，直接做乘法了。

 

 

 

 

毕向东 Java基础视频教程03天 15函数（重载）

１.   在同一个类中，允许多个同名函数存在，只要这些函数的参数个数和参数类型不一样就好

２.   当定义的函数的功能相同时，但是参与运算的未知量不同时，就定义同一个函数名表示函数功能，方便阅读，通过参数列表区别函数。

３.   对重载函数尽量提高代码复用性，以简化代码，在自定义函数中调用另一个自定义函数。

 

 

 

 

毕向东 Java基础视频教程03天 16函数（重载练习）

１.   void show(int x,double y, char z)

double  show( int a ,double b, char c)这俩个函数不可以同时存在于一个类当中。两个不是重载，因为参数的个数和类型都相同。

 

 

 

毕向东 Java基础视频教程03天 17数组（概述-内存结构）

１.   数组：同一种类型的数据的集合，是一个数据容器。

２.   用数组存数据的好处，会自动给存进来的数据编号，方便操作这些元素。

３.   用new在内存中产生一个容器实体。

４.   数组也是一种数据类型，属于引用数据类型。

５.   数组定义的格式：

元素类型 [] 数组名=new 元素类型[数组中元素个数]

 

６.   Java程序在启动时会在内存中开辟空间，为了提高运算效率，又对空间进行了不同划分，，每一个划分区域都有不同的数据处理方式和内存管理方式。有方法区，本地方法区，寄存器，栈内存，堆内存。栈内存用于存储局部变量 特点：数据使用完毕，变量会自动释放。堆不是。

７.   堆内存的每个实体都有一个存放位置，既然有位置就有首地址，把首地址赋给数组名，x就指向这个数组。数组并没有真正存放到x变量中去，x只存放数组的地址，它在引用这个数组而已。

８.   变量都要有个类型，比如int x，数组是引用类型变量，变量的值就是数组实体的首地址。类似于C语言指针变量，用于存放地址。

９.   Java中的数组是动态分配内存空间，在申明时不指定数组长度，而在初始化的时候进行。

１０.            数组：

先声明： int [] x;  申明并不是就在内存中开辟了该数组的内存空间，而是获得了该数组的地址变量，用于存放数组的地址，从而指向该数组实体。

初始化：new int[4]; 通过new操作符在内存中开辟了一个数组实体，对该数组实体进行初始化，有了存数据的地方，才可以往里面输入数据啊。

连接数组名x 和在内存中开辟的数组实体：x=new int[4]; 把数组实体的首地址赋给x,这样x就指向该数组实体，也叫做x引用数组实体，这样一个数组就创立好了。

三步简化为一行：

int [] x=new int [4];

１１.            堆内存中实体中的元素都有默认初始化值，初始化值根据元素的类型而定。

１２.            不想让x指向数组时，可以x=null;null是一个常量，是空的意思，x值为空。只有引用数据类型才可以用null.

１３.            垃圾回收机制：堆内存中的实体没有被引用时，java虚拟机视其为垃圾，垃圾不会立刻被清除掉，而是在不定时的时间内，启动垃圾回收机制，将数组实体在推内存中清除。C++是由程序员手动调用功能清除，若程序员忘做，该程序运行时间越长，程序越慢，甚至死机。占内存自动释放，堆内存不定时释放。

１４.            int [] x=new int[3];

int [] y=new int[3];注意这是两个不同数组，在堆内存中开辟了两个不同实体。

 

问题：数组变量为什么是局部变量，要在栈内存中开辟内存空间。

 

 

 

 

毕向东 Java基础视频教程04天 01数组（静态初始化 常见问题）

１.   静态初始化：用于数据少，并且都明确时

两种写法：

Int[] arr=new int[]{1,2,3,4,5}; 注意:[]内不要写数组长度

Int[] arr={1,2,3,4,5};(静态初始化的简化写法)

２.   编译时只检查语法，并不建立数组，只有运行时才建立数组

 

 

 

 

毕向东 Java基础视频教程04天 02数组（常见操作 遍历）

1.求数组长度：数组名.length   如 arr.length

2.求和就累加，累加等于变量加循环

3.数组名也是数组的首地址

4.定义一个函数打印数组中元素，定义函数考虑两个问题：有没有返回值，没有 void，有没有未知量，有，该数组，既然要传递一个数组那就要定义一个数组去接收这个数组，参数列表里（数组类型 数组名）（int[] arr） (接收数组指向原数组的数组实体)

 

 

 

毕向东 Java基础视频教程04天 03数组（常见操作 获取最值）

１.   获取最值需要顶一个一个变量，这个变量要么用来接收数组中的最大值，因为数组中的每个值和角标是一一对应的，所以获取 角标也就等于获取了该元素，所以这个变量也可以用来接收数组中最大值的角标。两种方法都要对变量初始化，max=arr[0]; 或者max=0;

 

 

 

毕向东 Java基础视频教程04天 04数组（从小到大排序 选择排序）

思路：

1.外循环控制比较的趟数，x初值取0，方便使用0角标的数组元素arr[0],因为比较的趟数比数组元素个数少一，在arr.lenght-1

2．   拿每一趟的首元素和其他元素一一比较， 考虑arr[x]和哪个元素比，首先arr[0]和arr[1]比，所以y初值1，当x=1,y=2,所以y=x+1,因为要把每一趟比完，所以y<arr.length

   开始比较，若首元素大就换位置，通过中间变量temp

   内循环结束一次，最值出现在本趟循环的首角标位置。

代码如下         {

                   int[] arr={5,3,9,1,4,6,0};

                   //排序前打印

                   printArray(arr);

                   //从小到大排序

                   selectSort(arr);

                   //排序后打印

                   printArray(arr);

         }

         public static void printArray(int[] arr)

         {

                   System.out.print("[");

                   for(int x=0;x<arr.length;x++)

                   {

                            if(x!=arr.length-1)

                                     System.out.print(arr[x]+",");

                            else

                                     System.out.println(arr[x]+"]");

                   }

         }

         public static void selectSort(int[] arr)

         {

                   for(int x=0;x<arr.length-1;x++)

                   {

                            for(int y=x+1;y<arr.length;y++)

                            {

                                     if(arr[x]>arr[y])

                                     {

                                               int temp=arr[x];

                                                        arr[x]=arr[y];

                                                        arr[y]=temp;

 

 

 

毕向东 Java基础视频教程04天 05数组（从小到大排序 冒泡排序）

１.   相邻两个交换，从小到大排序时，每一趟下来，都把最大值冒到该趟最后一个数组元素

              从大到小排序时，每一趟下来，都把最小值冒到该趟最后一个数组元素

 

选择排序和冒泡排序的异同：和选择排序刚好相反的是：选择排序是每次排序下来都把最值排在第一个元素，而冒泡排序是每一趟排序下来都把最值排在最后一个元素的位置。（就像先学的选择排序，在学的冒泡排序一样），选择排序是借用x和y角标一起来进行比较 ，冒泡排序只是用y角标进行比较

 

２.   分析：

通过外循环控制趟数，x不参与角标，只控制趟数

for(int x=0;x<arr.length-1;x++)

通过内循环控制每一趟的比较，因为每一趟比较都是从arr[0]开始，所以y=0;(变动区间能确定一头的就先确定一头，然后在确定另一头)

   对于任何一趟比较我们只要确定好了，比较开始的首位置和次位置，和比较的次数就行了。所以在比较开始的地方arr[0]和比较的次位置arr[y]>arr[y+1]确定好后，我们只需要控制好比较次数，也就是循环次数就行。

第一趟时比较的次数一定是y<arr.lenght-1，第二次比较的次数y<arr.length-2,也就推出

Y<arr.length-(x+1)

３.   printArr(arr);

bubbleSort(arr);

printArr(arr);

注意如果第一个printArr里用的是print();那么上下两个print的结果会显示在同一样

核心代码：

for(int x=0;x<arr.length-1;x++)

           {

                    for(int y=0;y<arr.length-(x+1);y++)

                    {

                             if(arr[y]>arr[y+1])

                             {

                                       int temp=arr[y];

                                                arr[y]=arr[y+1];

                                                arr[y+1]=temp;

４.   通过计算机排序

类上面：import java.util.*;

调用：  Arrays.sort(数组名)；

5.选择排序是知道比较开始的地方和比较结束的地方，冒泡排序是知道比较开始的地方和比较的次数更简便。

问题:冒泡排序 在堆内存中置换的次数减少可以提高性能，冒泡的优化方法

     希尔排序法

 

 

 

 

毕向东 Java基础视频教程04天 06数组（从小到大排序 位置置换功能抽取）

1.不管哪种排序，都有涉及到对一个数组内不同角标的两个值进行交换，代码功能一样，so我们可以抽取功能

public static void zhiHuan(int[] arr,int a,int b)

         {

                   int temp=arr[a];

                            arr[a]=arr[b];

                            arr[b]=temp;

 

 

 

毕向东 Java基础视频教程04天 07数组（折半查找）

１.   当返回值为int时，在运行自定义函数时，正常情况下可以得出这个返回值，但有时通过自定义函数确实没有找到我们想要的返回值时还是必须有返回值，不然系统会提示程序有误，此时根据情况返回一个不可能出现值就好了。

２.   在已知一个值然后查找它在数组中的位置时，首先对数组进行遍历。

public static int getIndex(int[] arr,int key)

{

           for(int x=0;x<arr.length;x++)

                    if(arr[x]==key)

                             return x;

           return -1;   没有找到该数时，依然要返回一个不可能值。必须放在循环之外

}

整除：不够除的时候，商为，余数为该书本身。

３.   折半查找必须是有序的数组

４.   凡事要用到某个类中的成员时，都要先产生class文件，然后再运行含有主函数的类。

问题：java.bak文件是编译时的报错文件吗

第一种：

这个循环条件有漏洞，对于该数组没有我们要找的数时，循环条件一直为真，那么循环会一直进行下去，运行之后没有结果。所以在循环类补了一个条件 ，针对没有该数的情况。

第二种（推荐）

思路：(通过角标)确定范围，判断范围，求中,考虑没有时。

关键思路：确定范围，判断范围，求中

//确定范围

Int min=0，max=arr.length-1, mid; 注意：最后一个角标是length-1

//判断范围

While(min<=max)

{

//求中：

mid=(min+max)/2;

//确定范围：

if(key<arr[mid])

      max=mid-1;

else if(key>arr[mid])

min=mid+1;

else

 return mid;

}

//考虑没有

return -1;

4，在数组中插入一个值

   如果该值是数组中的值，直接返回该值得角标，就插入在这个位置或下一个位置都行。

   如果该值不是数组中的值，返回min的值(通过实例证明)

 

无论数组是顺序还是倒序，再往左移和往右移时对min和max操作一样，往左移时把max=mid-1,往右移时min=mid+1,不同处只在于对key和arr[mid]进行比较后是左移还是右移而已。

简单一句话：是要左移还是右移不同，左移还是右移的方法都一样。而且无论顺序还是倒序，当数组中没有该值时，返回的min值都是该值的坐标。

在把一个数插入数组时，因为我们无法通过返回值直接判断数组中有没有该数，而不管有没有，都可以把返回值当做该数的角标。

 

 

 

毕向东 Java基础视频教程04天 08数组（十进制-二进制）

１.   十进制转二进制（也可调用（Integer.toBinaryString(num)）），八进制，十六进制，以十进制转八进制为例

思路：

建立while循环（因为要重复多次模一个数和整除一个数）和循环条件（整除到最后结果为0）所以循环条件为while（num>0）或者while(num!=0)，因为不等于零包括大于零和小于零，如果用小于零，直接第一个循环到最后就挂了。所以两者等价。）

模num并收录结果或者打印结果

循环之外：StringBuffer sb=new StringBuffer();

摸完：sb.append(num%2);

整除num再赋给num;

输出

System.out.println(sb.reverse());

定义函数进行十进制转化成二进制，八进制，十六进制时，直接在自定义函数中打印出结果，而不返回。

 

 

 

毕向东 Java基础视频教程04天 09数组（十进制-16进制）

１.   十进制转化成二进制:直接调用命令  或者while循环，先模2再整除2

２.   十进制转化成八进制，十六进制：先确定循环次数，先与再右移

以十进制转成16进制为例“

先确定循环次数

32/4=8

for(x=0;x<8;x++)

先与15赋给temp，然后判断

If(num&15>9)

                    sb.append((char)(num&15-10+’A’));   注意-10+’A’后一定要转成char

else

                    sb.append(num&15);

后右移

num=num>>>4;

核心代码

StringBuffer sb=new StringBuffer();

           for(int x=0;x<8;x++)

           {

                    int temp=num&15;  注意&完之后一定要用temp去接收，如果不用赋值，直接if(num&15>9)，比较运算符>是优先于&的，所以会先计算15>9==true,然后num&true,一个int,一个boolean，没法进行&

                    if(temp>9)

                             sb.append((char)(temp-10+'A'));

                    else

                             sb.append(temp);

                    num=num>>>4;

           }

           System.out.println(sb.reverse());

 

 

 

 

毕向东 Java基础视频教程04天 10数组（查表法十进制-16进制）

１.   字符数组一旦被定义，默认初始化值为‘\u0000’相当于空格

２.   不用-10+‘A’和StringBuffer，通过查表和数组接收输出地方法：（复杂）

 

之前十进制转换成16进制，把每一次&的结果都append到sb中，我们还可以用另一个容器数组，在把元素放进去时就顺着放，也就是把得出的第一个元素放在最后一位，这样的出来的十六进制就是正的了。

在对原数的二进制进行右移时，只要>>>到该数等于0，有效位已经完了，就没必要再&了,即便&下去等到的也是00003C。所以通过while(num!=0)

先通过建立对应表，把十六进制的字符用一个字符数组装起来，当我们得到15想取F是，因为在数组中chs[15]对应的就是F，所以直接取chs[&后的值]

然后把在数组中找到的字符，装在另个一字符数组的末位

pos=arr.length-1;

arr[pos--]=chs[&完后的值]  补充：pos- -和- -pos 都是先左后右

然后>>>

num=num>>>4;

最后通过循环输出数组，注意此时不是遍历输出，因为while(num!0)确保了arr[]中不存在前几位是0；

for(int x=pos+1;x<arr.length;x++)  注意：pos--，在取完最后一个有效值后，pos又- -

所以有效位是从pos+1开始。

代码：

public static void getHex(int num)

   {

            //需求：查表法把十进制转化成十六进制，用到数组表和数组装字符

            //建立数组表和数组容器

            char[] chs={'0','1','2','3',

                     '4','5','6','7',

                     '8','9','A','B',

                     'C','D','E','F'};

            char[] arr=new char[8];   //注意new char[8];不要犯低级错误int

            int pos=arr.length-1;   

            //建立循环一个个得到想要字符装在数组中

            while(num!=0)

            {

                     int temp=num&15;

                     arr[pos--]=chs[temp];

                     num=num>>>4;

            }

            for(int x=pos+1;x<arr.length;x++)

                     System.out.print(arr[x]);

   }

 

 

３.   这两种方法把十进制转换成十六进制一个结果是0000003C

一个是3C,是因为第一个用的for而不是用的while(num!=0)导致了8位的出现，只需要把for改成while就行，就变成了最优代码。

StringBuffer sb=new StringBuffer();

            while(num!=0)

            {

                     int temp=num&15;

                     if(temp>9)

                               sb.append((char)(temp-10+'A'));

                     else

                               sb.append(temp);

                     num=num>>>4;

            }

            System.out.println(sb.reverse());

 

 

 

 

 

毕向东 Java基础视频教程04天 11数组（查表法十进制-2进制）

１.   先&在移，同样方法运用于二进制

 

 

毕向东 Java基础视频教程04天 12数组（查表法十进制-2进制）

１.   对之前while(num!=0)的情况进行补充，在while之前

If(num==0)

{

            System.out.println(0);

   return ;

                   }

 

 

毕向东 Java基础视频教程04天 13数组（二维数组）

１.   System.out.println(arr); 输出来的是一个地址

２.   已知

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

System.out.println(arr[0]);打印出来结果还是一个地址，因为这是二维数组中的第一个数组，出来的就是他的地址

３.   int[][] arr=new int[3][];

对于三个一位数组arr[0],arr[1],arr[2]因为在堆内存都没有进行初始化，所以这三个数组地址变量的值都为NULL

４.   int[][] arr=new int[3][];

是在堆内存中开辟了三个一维数组的地址变量的内存空间，因为没有对三个一位数据进行初始化，所以这三个地址变量arr[0]arr[1]arr[2]不指向任何一维数组实体，值为NULL，既可以按照通常的方法统一对他们三个初始化，这是三个一维数组的元素个数相同，也可以单独进行初始化：

arr[0]=new int[3];

arr[1]=new int[1];

arr[2]=new int[2];

 

 

 

 

毕向东 Java基础视频教程04天 14数组（二维数组练习）

1.int[] x,y[];

  等价于

Int[] x;

Int[] y[]==int[][] y==int y[][];

---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------

详细请查看：<a href="http://edu.csdn.net/heima" target="blank">http://edu.csdn.net/heima</a>