StringBuffer与StringBuilder原理与区别使用场景

String 字符串常量

StringBuffer 字符串变量(线程安全)

StringBuilder 字符串变量(非线程安全)

blob.png

  • String:是不可改变的量,也就是创建后就不能在修改了。

  • StringBuffer:是一个可变字符串序列,它与 String 一样,在内存中保存的都是一个有序的字符串序列(char 类型的数组),不同点是 StringBuffer 对象的值都是可变的。

  • StringBuilder:与 StringBuffer 类基本相同,都是可变字符换字符串序列,不同点是 StringBuffer 是线程安全的,StringBuilder 是线程不安全的。

   StringBuffer 与 StringBuilder  底层也是 char[],

      数组初始化的时候就定下了大小, 如果不断的 append 肯定有超过数组大小的时候,我们是不是定义一个超大容量的数组,太浪费空间了。就像 ArrayList 的实现,采用动态扩展,每次 append 首先检查容量,容量不够就先扩展,然后复制原数组的内容到扩展以后的数组中,StringBuffer 是基于synchronized 来保证线程的安全性。

blob.png

使用场景:

使用 String 类的场景:在字符串不经常变化的场景中可以使用 String 类,例如常量的声明、少量的变量运算。

使用 StringBuffer 类的场景:在频繁进行字符串运算(如拼接、替换、删除等),并且运行在多线程环境中,则可以考虑使用 StringBuffer,例如 XML 解析、  HTTP 参数解析和封装。

使用 StringBuilder 类的场景:在频繁进行字符串运算(如拼接、替换、和删除等),并且运行在单线程的环境中,则可以考虑使用 StringBuilder,如 SQL 语句的拼装、JSON 封装等。

String的性能分析

 延续上篇String的分析文章,<<深入理解String>>   本将章分析一下String的几个方法的性能优化;

一、 String substring的内存泄漏:

   在JDK6的源码实现:

  image.png

image.png

   在源码的注释中说明,这是一个包作用域的构造函数,其目的是为了能高效且快速地共享String内的char数组对象。但在这种通过偏移量来截取字符串的方法中,String的原生内容value数组被复制到新的子字符串中。设想,如果原始字符串很大,截取的字符串长度却很短,那么截取的子字符串中包含了原生字符串的所有内容,并占据了相应的空间,而仅仅通过偏移量和长度来决定自己的实际价值。这种算法提高了运算速度却浪费了大量的内存空间。

  对于为什么使用不当会出现内存的泄漏情况, 

 通过以下代码重现:

public class LeakTest {  
    public static void main(String...args) {  
        List<String> handler = new ArrayList<String>();  
        for(int i = 0; i < 100000; i++) {  
            Huge h = new Huge();  
            handler.add(h.getSubString(1, 5));  
        }  
    }  
}  
  
class Huge {  
    private String str = new String(new char[100000]);  
    public String getSubString(int begin, int end) {  
        return str.substring(begin, end);  
    }  
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space


      按理来说,Full GC 后是对Huge对象的回收,并且释放所占有的内存,但是由于JDK 6进行substring时,使用共享内容字符数组,依然持有原有char[100000]的空间引用. 这种方式的有点就是速度更加快,不需要重新申请内存 。

     Java 7 中substring的实现抛弃了之前的内容字符数组共享的机制,对于子字符串(自身除外)采用了数组复制实现单个字符串持有自己的应该拥有的内容。

   image.png

  这种方式采用了空间换时间的方式,每次操作substring性能上,会比jdk6方式的差点;

二、字符串分割和查找

    字符串的分割和查找也是字符串处理中最常用的方法之一,

       public String[] split(String regex)

    比如"a,b;c,d",我要分割该字符串,可以使用如下正则进行分割处理,

     String []arrays="a,b;c,d".split("[,|;]");

     split本身具有强大的功能,恰当使用,能否提供编程的效率,但是在性能的表现上并不理想;

     在使用上,可以使用效率更加高的StringTokenizer类分割字符串;

    StringTokenizer是jdk提供专门用来处理字符串分割的工具类,

    提供的函数:

        StringTokenizer st = new StringTokenizer(str,"\\s");

    String 与 StringTokenizer 之间的性能对比:

public class StringTest {

	public static void main(String[] args) {
		String str = buildString(1_000_000); //1.7新特性, 1000000
		long start;
		long end;
		
		System.out.println("-----------StringTokenizer start-----------");		
		start = System.currentTimeMillis();
		StringTokenizer st = new StringTokenizer(str);
		StringBuilder sb = new StringBuilder();
		while(st.hasMoreTokens()){
			sb.append(st.nextToken());
		}
		end = System.currentTimeMillis();
		System.out.println("StringTokenizer time use:" + (end-start));
		
		System.out.println("-----------StringSpilt start-----------");		
		start = System.currentTimeMillis();
		StringBuilder sb2 = new StringBuilder();
		String[] strs = str.split("\\s");
		for(String s: strs){
			sb2.append(s);
		}
		end = System.currentTimeMillis();
		System.out.println("StringSpilt time use:" + (end-start));		
		
	}
	
	//建立一个长字符串,
	//其中有空格,以便拆分成length长度的n个字符串
	private static String buildString(int length) {
		StringBuilder sb = new StringBuilder();
		Random r =new Random();
		for (int i = 0; i <length;i++ ){
			for (int j = r.nextInt(10); j>0 ;j--){
				sb.append((char)('a' + r.nextInt(26)));
			}
			sb.append(" ");
		}		
		return sb.toString();
	}
}

输入的大概结果:

    ———–StringTokenizer start———–

StringTokenizer time use:447

     ———–StringSpilt start———–

StringSpilt time use:2416

三、字符串的查找:

   在软件开发的过程中,我们常常判断一个字符串是否以"xx"开头或者结尾,使用startswith()或者endstartwith()来实现,

   String str="java_xx";

   boolean result=str.startswith("java");

   boolean result=str.endstartwith("xx");

   即便这种方式是java的内置函数,但在效率上也远远低于charAt()方法,

   如:

     if(str.charAt(0)=='j' && str.charAt(0)=='a'&& str.charAt(0)=='v' && str.charAt(0)=='a');

      if(str.charAt(str.length-1)=='x' && str.charAt(str.length-2)=='x');

  在高度频繁判断字符串是否以"xx"开头或者结尾,可以使用charAt方式实现,但是不灵活;

四、字符串的拼接上:

   在于拼接字符串上,推荐使用Stringbuilder和Stringbuffer,实在比较少字数的拼接,可以使用String.concat()方法来实现拼接;

深入理解String

  • Java常量池技术

        java中的常量池技术,是为了方便快捷地创建某些对象而出现的,当需要一个对象时,就可以从池中取一个出来(如果池中没有则创建一个),则在需要重复创 建相等变量时节省了很多时间。常量池其实也就是一个内存空间,不同于使用new关键字创建的对象所在的堆空间。 String类也是java中用得多的类,同样为了创建String对象的方便,也实现了常量池的技术。

      对于String常量,它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的, 对于String类型,有一张固定长度的CONSTANT_String_info表用来存储文字字符串值,注意:该表只存储文字字符串值,不存储符号引用。说到这里,对常量池中的字符串值的存储位置应该有一个比较明了的理解了。在程序执行的时候,常量池会储存在Method Area,而不是堆中。常量池中保存着很多String对象; 并且可以被共享使用,因此它提高了效率

     String是一个不可变对象 基于final,可以认为是特殊的常量,因此存在方法区的运行时常量池中,可以被共享使用,以提高效率。

题外话:

      Java中基本类型的包装类的大部分都实现了常量池技术,这些类是 Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类(有小数点精度)则没有实现。另外 Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池,也即对象不负责 创建和管理大于127的这些类的对象。一些对应的测试代码:

    Integer i1=127;    
    Integer i2=127;
    System.out.println(i1==i2); //输出true
    //值大于127时,不会从常量池中取对象
    Integer i3=128;
    Integer i4=128;
    System.out.println(i3==i4); //输出false
  • 关于equals和==区别:

       详细的解析可以看 Java中的equals和==  文章;

public class TimerTest {
      public static void main(String[] args) {  
        /** 
         * 情景一:字符串池 
         * JAVA虚拟机(JVM)中存在着一个字符串池,其中保存着很多String对象; 
         * 并且可以被共享使用,因此它提高了效率。 
         * 由于String类是final的,它的值一经创建就不可改变。 
         * 字符串池由String类维护,我们可以调用intern()方法来访问字符串池。  
         */  
        String s1 = "abc";     
        //↑ 在字符串池创建了一个对象  
        String s2 = "abc";     
        //↑ 字符串pool已经存在对象“abc”(共享),所以创建0个对象,累计创建一个对象  
        System.out.println("s1 == s2 : "+(s1==s2));   //true  
        //↑ true 指向同一个对象,  
        System.out.println("s1.equals(s2) : " + (s1.equals(s2)));     //true
        //↑ true  值相等  
        //↑------------------------------------------------------over  /** 
          
        
        /* 
         *   情景二:关于new String("") 
         * 
         * */
        String s3 = new String("abc");  
        //↑ 创建了两个对象,一个存放在字符串池中,一个存在与堆区中;,还有一个对象引用s3存放在栈中   
        String s4 = new String("abc");  
        //↑ 字符串池中已经存在“abc”对象,所以只在堆中创建了一个对象  ,判断引用地址是否相同
        System.out.println("s3 == s4 : "+(s3==s4));   //false
        //↑false   s3和s4栈区的地址不同,指向堆区的不同地址 对象内容相等;  
        System.out.println("s3.equals(s4) : "+(s3.equals(s4)));  //true
        //↑true  s3和s4的值相同  ,equals 两个对象内容是否相等,因为String重写了equals方法。
        System.out.println("s1 == s3 : "+(s1==s3));   //false
        //↑false 存放的地区多不同,一个栈区,一个堆区  
        System.out.println("s1.equals(s3) : "+(s1.equals(s3)));  //true
        //↑true  值相同  
        //↑------------------------------------------------------over  
        
       /*  * 情景三:  
         * 由于常量的值在编译的时候就被确定(优化)了。 
         * 在这里,"ab"和"cd"都是常量,因此变量str3的值在编译时就可以确定。 
         * 这行代码编译后的效果等同于: String str3 = "abcd";
         * 
         *  */
        String str1 = "ab" + "cd";  //1个对象  
        String str11 = "abcd";   
        System.out.println("str1 = str11 : "+ (str1 == str11));   //true
        //↑------------------------------------------------------over  
        
     /* * 情景四:  
         * 局部变量str2,str3存储的是存储两个字符串对象(intern字符串对象)的地址。 
         *  
         * 第三行代码原理(str2+str3): 
         * 运行期JVM首先会在堆中创建一个StringBuilder类, 
         * 同时用str2指向的拘留字符串对象完成初始化, 
         * 然后调用append方法完成对str3所指向的拘留字符串的合并, 
         * 接着调用StringBuilder的toString()方法在堆中创建一个String对象, 
         * 最后将刚生成的String对象的堆地址存放在局部变量str3中。 
         *  
         * 而str5存储的是字符串池中"abcd"所对应的拘留字符串对象的地址。 
         * str4与str5地址当然不一样了。 
         *  
         * 内存中实际上有五个字符串对象: 
         *       三个拘留字符串对象、一个String对象和一个StringBuilder对象。 
         *       
         *       */
        String str2 = "ab";  //1个对象  
        String str3 = "cd";  //1个对象                                         
        String str4 = str2+str3;                                        
        String str5 = "abcd";    
        System.out.println("str4 = str5 : " + (str4==str5)); // false  
        //↑------------------------------------------------------over  /** 
       
        
        /*  
        * * 情景五: 
         *  JAVA编译器对string + 基本类型/常量 是当成常量表达式直接求值来优化的。 
         *  运行期的两个string相加,会产生新的对象的,存储在堆(heap)中 
         *  
         *  */
        String str6 = "b";  
        String str7 = "a" + str6;  
        String str67 = "ab";  
        System.out.println("str7 = str67 : "+ (str7 == str67));  //false
        //↑str6为变量,在运行期才会被解析。  
        final String str8 = "b";  
        String str9 = "a" + str8;  
        String str89 = "ab";  
        System.out.println("str9 = str89 : "+ (str9 == str89));   //true//↑str8为常量变量,编译期会被优化  
        //↑------------------------------------------------------over  
    }
}

  • 了解String:

 blob.png

         图片可以看出String类初始化后是不可变的(immutable)

          大家只要知道String的实例一旦生成就不会再改变了,比如说:String str=”kv”+”ill”+” “+”ans”; 就是有4个字符串常量,首先”kv”和”ill”生成了”kvill”存在内存中,然后”kvill”又和” ” 生成 “kvill “存在内存中,最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的”不可变”产生了很多临时变量,这也就是为什么建议用StringBuffer的原 因了,因为StringBuffer是可改变的。

     下面是一些String相关的常见问题:

        String中的final用法和理解 
      final StringBuffer a = new StringBuffer("111"); 
      final StringBuffer b = new StringBuffer("222"); 
       a=b;//此句编译不通过  final StringBuffer a = new StringBuffer("111"); 
      a.append("222");// 编译通过 

     可见,final只对引用的"值"(即内存地址)有效,它迫使引用只能指向初始指向的那个对象,改变它的指向会导致编译期错误。至于它所指向的对象的变化,final是不负责的。 

      2.代码中的字符串常量在编译的过程中收集并放在class文件的常量区中,如"123"、"123"+"456"等,含有变量的表达式不会收录,如"123"+a。

      3.JVM在加载类的时候,根据常量区中的字符串生成常量池,每个字符序列如"123"会生成一个实例放在常量池里,这个实例是不在堆里的,也不会被GC,这个实例的value属性从源码的构造函数看应该是用new创建数组置入123的,所以按我的理解此时value存放的字符数组地址是在堆里,如果有误的话欢迎大家指正。

  • 使用String不一定创建对象:

      在执行到双引号包含字符串的语句时,如String a = "123",JVM会先到常量池里查找,如果有的话返回常量池里的这个实例的引用,否则的话创建一个新实例并置入常量池里。如果是 String a = "123" + b (假设b是"456"),前半部分"123"还是走常量池的路线,但是这个+操作符其实是转换成[SringBuffer].Appad()来实现的,所以最终a得到是一个新的实例引用,而且a的value存放的是一个新申请的字符数组内存空间的地址(存放着"123456"),而此时"123456"在常量池中是未必存在的。

要注意: 我们在使用诸如String str = "abc";的格式定义类时,总是想当然地认为,创建了String类的对象str。担心陷阱!对象可能并没有被创建!而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象

  • 使用new String 一定创建对象:

     在执行String a = new String("123")的时候,首先走常量池的路线取到一个实例的引用,然后在堆上创建一个新的String实例,走以下构造函数给value属性赋值,然后把实例引用赋值给a:

   blob.png

  

  • String.intern():

   String对象的实例调用intern方法后,可以让JVM检查常量池,如果没有实例的value属性对应的字符串序列比如"123"(注意是检查字符串序列而不是检查实例本身),就将本实例放入常量池,如果有当前实例的value属性对应的字符串序列"123"在常量池中存在,则返回常量池中"123"对应的实例的引用而不是当前实例的引用,即使当前实例的value也是"123"

    blob.png

       nativ:表示本地方法

   存在于.class文件中的常量池,在运行期被JVM装载,并且可以扩充。String的 intern()方法就是扩充常量池的 一个方法;当一个String实例str调用intern()方法时,Java 查找常量池中 是否有相同Unicode的字符串常量,如果有,则返回其的引用,如果没有,则在常 量池中增加一个Unicode等于str的字符串并返回它的引用;看示例就清楚:

public class TimerTest {
    public static void main(String[] args) {
        String s0 = "kvill";
        String s1 = new String("kvill");
        String s2 = new String("kvill");
        System.out.println(s0 == s1); // false
        System.out.println("**********");
        s1.intern(); // 虽然执行了s1.intern(),但它的返回值没有赋给s1
        s2 = s2.intern(); // 把常量池中"kvill"的引用赋给s2
        System.out.println(s0 == s1); // flase
        System.out.println(s0 == s1.intern()); // true//说明s1.intern()返回的是常量池中"kvill"的引用
        System.out.println(s0 == s2); // true
    }
}

Java中的equals和==

在初学Java时,可能会经常碰到下面的代码:

1 String str1 = new String("hello");
2 String str2 = new String("hello");      
3 System.out.println(str1==str2);
4 System.out.println(str1.equals(str2));

为什么第3行和第4行的输出结果不一样?==和equals方法之间的区别是什么?

一.关系操作符“==”到底比较的是什么?

《Java编程思想》一书中的原话:“关系操作符生成的是一个boolean结果,它们计算的是操作数的值之间的关系”。

    这句话看似简单,理解起来还是需要细细体会的。说的简单点,==就是用来比较值是否相等。下面先看几个例子:

    public class Test {        
        public static void main(String[] args) {
        int a=3;
        int b=3;
        System.out.println(a==3);
        String str = new String("test");
        String str1 = new String("test");
        String str2 = new String("test");
            System.out.println(str1==str2);
            str1 = str;
            str2 = str;
            System.out.println(str1==str2);
        }
     }

    输出结果为 true false true true;

       n==m结果为true,这个很容易理解,变量n和变量m存储的值都为3,肯定是相等的。而为什么str1和str2两次比较的结果不同?要理解这个其实只需要理解基本数据类型变量和非基本数据类型变量的区别。

  在Java中游8种基本数据类型:

  浮点型:float(4 byte), double(8 byte)

  整型:byte(1 byte), short(2 byte), int(4 byte) , long(8 byte)

  字符型: char(2 byte)

  布尔型: boolean(JVM规范没有明确规定其所占的空间大小,仅规定其只能够取字面值"true"和"false")

    对于这8种基本数据类型的变量,变量直接存储的是“值”,因此在用关系操作符==来进行比较时,比较的就是 “值” 本身。要注意浮点型和整型都是有符号类型的,而char是无符号类型的(char类型取值范围为0~2^16-1).

      也就是说比如:

      int n=3;

      int m=3; 

      变量n和变量m都是直接存储的"3"这个数值,所以用==比较的时候结果是true。

      而对于非基本数据类型的变量,在一些书籍中称作为 引用类型的变量。比如上面的str1就是引用类型的变量,引用类型的变量存储的并不是 “值”本身,而是于其关联的对象在内存中的地址。比如下面这行代码:

      String str1;

    这句话声明了一个引用类型的变量,此时它并没有和任何对象关联。

    而 通过new String("hello")来产生一个对象(也称作为类String的一个实例),并将这个对象和str1进行绑定:

      str1= new String("hello");

    那么str1指向了一个对象(很多地方也把str1称作为对象的引用),此时变量str1中存储的是它指向的对象在内存中的存储地址,并不是“值”本身,也就是说并不是直接存储的字符串"hello"。这里面的引用和C/C++中的指针很类似。

    因此在用==对str1和str2进行第一次比较时,得到的结果是false。因此它们分别指向的是不同的对象,也就是说它们实际存储的内存地址不同。而在第二次比较时,都让str1和str2指向了str指向的对象,那么得到的结果毫无疑问是true。

      二.equals比较的又是什么?

       下面是Object类中equals方法的实现:     

       public boolean equals(Object obj) {
           return (this == obj);
        }

       equals方法是基类Object中的方法,因此对于所有的继承于Object的类都会有该方法。 由此可以看出:equals方法是用来比较两个对象的引用是否相等,即是否指向同一个对象

     public class Test {
         public static void main(String[] args) {
            String str1 = new String("test");
            String str2 = new String("test");
            System.out.println(str1.equals(str2));
       }
      }

 要知道究竟,可以看一下String类的equals方法的具体实现,同样在该路径下,String.java为String类的实现。

  下面是String类中equals方法的具体实现:     

    /**
     * Compares this string to the specified object.  The result is {@code
     * true} if and only if the argument is not {@code null} and is a {@code
     * String} object that represents the same sequence of characters as this
     * object.
     *
     * @param  anObject
     *         The object to compare this {@code String} against
     *
     * @return  {@code true} if the given object represents a {@code String}
     *          equivalent to this string, {@code false} otherwise
     *
     * @see  #compareTo(String)
     * @see  #equalsIgnoreCase(String)
     */
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

     可以看出,String类对equals方法进行了重写,用来比较指向的字符串对象所存储的字符串是否相等。

     判断依据:1、判断两个字符串的长度是否一致、 2、判断字符数组里面的char值是否一致,如果有一个不等,则说明两个字符串不相等。

     其他的一些类诸如Double,Date,Integer等,都对equals方法进行了重写用来比较指向的对象所存储的内容是否相等。

     
    Integer类:
      public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
      }
  
    Date:
      public boolean equals(Object obj) {
          return obj instanceof Date && getTime() == ((Date) obj).getTime();
      }

总结来说:

  1)对于==,如果作用于基本数据类型的变量,则直接比较其存储的 “值”是否相等;

   如果作用于引用类型的变量,则比较的是所指向的对象的地址(判断引用地址是否相同)

      ==操作符专门用来比较两个变量的值是否相等,也就是用于比较变量所对应的内存中所存储的数值是否相同,要比较两个基本类型的数据或两个引用变量是否相等,只能用==操作符。如果一个变量指向的数据是对象类型的,那么,这时候涉及了两块内存,对象本身占用一块内存(堆内存),变量也占用一块内存,例如Objet obj = new Object();变量obj是一个内存,new Object()是另一个内存,此时,变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量,如果要比较两个变量是否指向同一个对象,即要看这两个变量所对应的内存中的数值是否相等,这时候就需要用==操作符进行比较

  2)对于equals方法,注意:equals方法不能作用于基本数据类型的变量

    如果没有对equals方法进行重写,则比较的是引用类型的变量所指向的对象的地址,因为使用的

    诸如String、Date等类对equals方法进行了重写的话,比较的是所指向的对象的内容。

值传递与引用传递

1:按值传递是什么

指的是在方法调用时,传递的参数是按值的拷贝传递。示例如下:

public class TempTest {  
private void test1(int a){  
//做点事情  
}  
public static void main(String[] args) {  
TempTest t = new TempTest();  
int a = 3;  
t.test1(a);//这里传递的参数a就是按值传递  
}  
}

按值传递重要特点:传递的是值的拷贝,也就是说传递后就互不相关了。

示例如下:

public class TempTest {  
   private void test1(int a){  
     a = 5;  
     System.out.println("test1方法中的a="+a);  
} 
   
  public static void main(String[] args) {  
     TempTest t = new TempTest();  
     int a = 3;  
     t.test1(a);//传递后,test1方法对变量值的改变不影响这里的a  
      System.out.println(”main方法中的a=”+a);  
  }  
}

1468388959805222.png

2:按引用传递是什么:

指的是在方法调用时,传递的参数是按引用进行传递,其实传递的引用的地址,也就是变量所对应的内存空间的地址。

示例如下:

     public class TempTest {
               
        private void test1(A a){  
        
        }
          
        public static void main(String[] args) {  
           TempTest t = new TempTest();  
            A a = new A();  
            t.test1(a); //这里传递的参数a就是按引用传递  
        }  
      }  
      class A{  
           public int age = 0;  
      }

3:按引用传递的重要特点

传递的是值的引用,也就是说传递前和传递后都指向同一个引用(也就是同一个内存空间)。

示例如下:

   blob.png

4:理解按引用传递的过程——内存分配示意图

要想正确理解按引用传递的过程,就必须学会理解内存分配的过程,内存分配示意图可以辅助我们去理解这个过程。

用上面的例子来进行分析:

 (1):运行开始,运行第8行,创建了一个A的实例,内存分配示意如下:

     blob.png

(2):运行第9行,是修改A实例里面的age的值,运行后内存分配示意如下:

     blob.png

(3):运行第10行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

内存分配示意如下:

       blob.png

由于是按引用传递,也就是传递的是内存空间的地址,所以传递完成后形成的新的内存示意图如下:

      blob.png

也就是说:是两个变量都指向同一个空间。

(4):运行第3行,为test1方法中的变量a指向的A实例的age进行赋值,完成后形成的新的内存示意图如下:

此时A实例的age值的变化是由test1方法引起的

      blob.png

(5):运行第4行,根据此时的内存示意图,输出test1方法中的age=20

(6):运行第11行,根据此时的内存示意图,输出main方法中的age=20