数组分配的字节码分析

int [][]a=new int[3][5];
System.out.println(a[0][0]);

会打印出 0
可以得出另外
引用类型的数组不赋值里面存储的都是 null
基本数据类型，譬如 int 不赋值存储的是 0；
double float 不赋值默认存储的都是是 0.
基本数据类型  数组存储的是数据 而引用存储的是引用....

String[] x = {"o", "k","ok"}; 

这里存储的是String对象的引用....

int[] x = {0}; 与 int[] x = new int[1]

通过查看字节码  可以得知 是 一样的效果...

 //    0    0:iconst_1        
    //    1    1:newarray        int[]
    //    2    3:dup             
    //    3    4:iconst_0        
    //    4    5:iconst_0        
    //    5    6:iastore         
    //    6    7:astore_1        
    //    7    8:iconst_1        
    //    8    9:newarray        int[]
    //    9   11:astore_2        
    //   10   12:return      

int[][] x = {{1},{1,2},{1,2,3},new int[1]}; 

查看字节码

  public static void main(String args[])
    {
    //    0    0:iconst_3        
    //    1    1:anewarray       int[][]
    //    2    4:dup             
    //    3    5:iconst_0        
    //    4    6:iconst_2        
    //    5    7:newarray        int[]
    //    6    9:dup             
    //    7   10:iconst_0        
    //    8   11:iconst_2        
    //    9   12:iastore         
    //   10   13:dup             
    //   11   14:iconst_1        
    //   12   15:iconst_3        
    //   13   16:iastore         
    //   14   17:aastore         
    //   15   18:dup             
    //   16   19:iconst_1        
    //   17   20:iconst_2        
    //   18   21:newarray        int[]
    //   19   23:dup             
    //   20   24:iconst_0        
    //   21   25:iconst_1        
    //   22   26:iastore         
    //   23   27:dup             
    //   24   28:iconst_1        
    //   25   29:iconst_5        
    //   26   30:iastore         
    //   27   31:aastore         
    //   28   32:dup             
    //   29   33:iconst_2        
    //   30   34:iconst_2        
    //   31   35:newarray        int[]
    //   32   37:dup             
    //   33   38:iconst_0        
    //   34   39:iconst_3        
    //   35   40:iastore         
    //   36   41:dup             
    //   37   42:iconst_1        
    //   38   43:iconst_4        
    //   39   44:iastore      将int类型存入数组   
    //   40   45:aastore      将引用类型存入数组 （二维的）   
    //   41   46:astore_1        
    //   42   47:aload_1         
    //   43   48:invokestatic    #3   <Method void change(int[][])>
    //   44   51:getstatic       #4   <Field PrintStream System.out>
    //   45   54:aload_1         
    //   46   55:iconst_0        
    //   47   56:aaload             //   48   57:iconst_0        
    //   49   58:iaload          
    //   50   59:invokevirtual   #5   <Method void PrintStream.println(int)>
    //   51   62:return          
    }

//还要注意 创建一维数组和多维数组是不一样的命令
int [][]a=new int[3][5];
注意 这里 通过字节码可以看出  x二维数组放的不是15个int元素 而是 3个int数组对象
一个是newarray是基本类型数组
另一个是anewarray的放入引用类型的数组  所以这两种数组不是一个Class

    public static void change(int ai[][])
    {
    //    0    0:aload_0   从局域变量0中加载引用类型的值   
    //    1    1:iconst_0  将0压入栈  
    //    2    2:aaload    从数组装入引用的值  获得了a[0]
    //    3    3:iconst_0  将0压入栈
    //    4    4:iconst_1  将1压入栈
    //    5    5:iastore   对数组赋值a[0][0] 类型是int  注意 如果是普通的引用的话赋值是 用astore_1  这就是数组为什么是引用传递 而引用是值传递！
      
    //    6    6:return          
    }

对应的方法

public static void main(String[] args) {
		// TODO Auto-generated method stub

int a[][]={{2,3},{1,5},{3,4}};

change(a);
System.out.println(a[0][0]);
}
public static void change(int[][]a)
{
a[0][0]=1;
}
}

如果有个方法change里面的参数是StringBuffer,在change里面进行了append
那他会改变吗》》？？

public static void main(String[] args) {
		// TODO Auto-generated method stub

	 StringBuffer   buffA=new   StringBuffer( "a "); 
           StringBuffer   buffB=new   StringBuffer( "b "); 
           change(buffA,buffB); 
	  System.out.println(buffA+ ", "+buffB); 

	}
	public static void change(StringBuffer x,StringBuffer y){
           x.append(y); 
	     y=x; 

再看
他的字节码

 //    0    0:aload_0         
    //    1    1:aload_1         
    //    2    2:invokevirtual   #15  <Method StringBuffer StringBuffer.append(StringBuffer)>
    //    3    5:pop        弹出栈顶的值  这也就是为什么StringBuffer能够起到引用传递的内容.....     
    //    4    6:aload_0         
    //    5    7:astore_1        
    //    6    8:return