1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                
   
5.                 String str1 = "aa";
   
6.                 String str2 = new String("aa");
   
7.                 String str3 = "aa";
   
8.                
   
9.                 /**
   
10.                  * ==是比较两个对象的内存空间
    
11.                  * 对于String对象的直接赋值，
    
12.                  * 如String str1 = "aa"; "aa"字符串是存储于静态内存区的，而且是唯一的。
    
13.                  * 因此str1和str3指向的是同一块内存
    
14.                  * str1和str2指向的是不同的内存
    
15.                  */
    
16.                 System.out.println(str1==str2);//false
    
17.                 System.out.println(str1==str3);//true
    
18.                
    
19.                 //equals方法不比较内存空间，只比较两者的值
    
20.                 System.out.println(str1.equals(str2));
    
21.                 System.out.println(str1.equals(str3));
    
22.                
    
23.                
    
24.                 /**
    
25.                  * StringBuffer的使用
    
26.                  * 举一个例子:
    
27.                  *         写一个循环获取12345678910--------一直到999;
    
28.                  */
    
29.                 /*首先我们看一下用String连接符怎么写的,再来分析一下他的内存模型
    
30.                  * 在内存模型中我们可以看到，
    
31.                  * 第一次循环我们定义了一个"1"的字符串，赋值给num1
    
32.                  * 第二次我们定义了一个"12"的字符串,赋值给num1，（这个时候注意字符串"1"没有回收，只是将num1的指针指向了"12"）
    
33.                  * 以此推类：这样的100次循环，开辟了100块内存，但我们需要的只有一个
    
34.                  * 那么100次，一万次呢？
    
35.                  */
    
36.                 String num1 = "";
    
37.                 for(int i=0;i<100;i++){
    
38.                         num1 += i;
    
39.                 }
    
40.                 System.out.println(num1);
    
41.                
    
42.         }
    
43. }
    

复制代码

1. public class Test1 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                
   
5.                 /*让我们来看一下StringBuffer，
   
6.                  * 来分析一下他的内存，我们就可以清楚的知道为什么类似的情况会选择实用StringBuffer了
   
7.                  * sb指向堆内存的一个对象，这个对象指向静态区的一个字符串
   
8.                  * sb.append()方法只会开辟一块内存空间。这样就大大的节省了内存（相比于上次的方式）
   
9.                  *
   
10.                  * StringBuffer和StringBuilder的区别
    
11.                  *     StringBuffer线程安全，效率低
    
12.                  *     StringBuilder线程不安全，效率高
    
13.                  */
    
14.                 StringBuffer sb = new StringBuffer();
    
15.                 for(int k = 1;k<100;k++){
    
16.                         sb.append(k);
    
17.                 }
    
18.                 System.out.println(sb.toString());
    
19.         }
    
20. }

复制代码

如果有错误的地方，请各位大神指出，大家多交流交流，共同进步。

谢谢分享~~~~

好牛逼啊，佩服！