JAVA内存中的对象

╰+攻爆jí腚メ 2022-08-05 12:07 177阅读 0赞

**一、基本数据类型的内存分配**

**代码1：**

Java代码   ![收藏代码][icon_star.png]

1.  int p1=1000;  
2.  static  int p2=1000;  
3.  public void myTest()\{  
4.  System.err.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*Integer\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");   
5.  int i1=1000;  
6.  int i2=1000;  
7.  Integer i3=1000;  
8.  Integer i4=1000;  
9.  Integer i5=100;  
10. Integer i6=100;  
11. Integer i7=new Integer(1000);  
12. Integer i8=new Integer(1000);   
13. System.err.println(i1==p1);  //true(输出结果)   1（编号，便于分析）  
14. System.err.println(i1==p2);  //true                  2  
15. System.err.println(i1==i2);  //true                   3  
16. System.err.println(i3==i4);  //false                  4  
17. System.err.println(i5==i6);  //true                   5  
18. System.err.println(i7==i8);  //false                  6  
19. System.err.println(i1==i3);  //true                   7  
20. System.err.println(i1==i7);  //true                   8  
21. System.err.println(i3==i7);  //false                  9  
22. System.err.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*Integer\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
23. \}

看到上面的输出结果，如果你还是有些不能理解的，那就耐心地接着看我的分析吧。

**分析：**

编号1：在java编译时期，当编译到“int p1=1000; ”时会在栈中压入1000，其实后面的p2,i1,i2都是指向这个1000，这样可以提高java的性能，所以编号1、编号2、编号3的输出结果都是true.其实char,float,double等基本数据类型都是这样的。

编号2、编号3：同编号1

编号4：这是java中的自动装箱机制，将基本数据类型int自动转为类类型Integer,这是jdk1.5以上才有的功能，jdk1.5以下编译时会报错。自动装箱时java底层会调用Integer.valueOf(int i)方法自动装箱，下面我们来看看Integer.valueOf(int i)的源码吧：

Java代码   ![收藏代码][icon_star.png]

1.  /\*\*   
2.  \* @param  i an <code>int</code> value. 
3.       \* @return a <tt>Integer</tt> instance representing <tt>i</tt>. 
4.       \* @since  1.5 
5.       \*/  
6.      public static Integer valueOf(int i) \{  
7.          if(i >= -128 && i <= IntegerCache.high)  
8.              return IntegerCache.cache\[i + 128\];  
9.          else  
10.             return new Integer(i);  
11.     \}

**注：分析源码我们知道IntegerCache.high其实就是127，在IntergerCache的静态块中定义的。**

源码的意思是当i的值在-128—127之间时会返回IntegerCache.cache\[\]中的对象，其他的新建一个Integer对象。其实Integer类是这样实现的：考虑到-128—127之间的对象经常使用，就在Integer创建时将值在-128—127之间的对象先创建好，放在池中，以后要使用时，这些对象就不用重新创建了，目的在于提高性能。其实这种机制在Character中也用到了，Character是创建ASCII在0—127之间的对象。补充说明：Integer创建的对象引用在栈中，对象的内容在堆区，栈中的值是堆中对象的地址。Character、Long、Short等包装类都是这样的。所以编号4的输出结果是false,因为值大于127，java新创建了一个对象。

编号5：因为值在-128—127之间，所以两个引用指向的是堆区的同一个对象。

编号6：当使用new创建对象时，都会新创建一个对象，即在栈中创建一个引用，在堆中创建该对象，引用指向对象。

编号7：这种情况有些人可能会不太清楚，其实这是java的自动拆箱机制，当int和Integer发生操作时，Integer类型对象会自动拆箱成int值，这时比较的是两个int值，而我们前面分析了，int值都会指向常量池中的数据，所以，两者指向的是同一块空间。结果编号7输出true

编号8：同编号7，也是Integer的自动拆箱。

编号9：我想，分析了这么多，编号9不用我说，你也应该懂了，呵呵，这里就不赘述了哦~  
分析了这么多，终于第一块代码分析完了。

**二、String类型的内存分配**

大家都知道String类型是类类型，不过String类型是一个特殊的类类型，那它特殊在哪呢？  
**代码2：**

Java代码   ![收藏代码][icon_star.png]

1.         System.err.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*string\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");     
2.   String s1="abc";  
3.   String s2="abc";  
4.   String s3=new String("abc");  
5.   String s4=new String("abc");  
6.   System.err.println(s1==s2);//true （输出结果） 1（编号）  
7.   System.err.println(s3==s4);//false                   2  
8.   System.err.println(s1==s3);//false                    3  
9.     
10.  String a = "abc";     
11. String b = "ab";     
12. String c = b + "c";    
13. System.err.println(a==c);//false                         4  
14.   
15.  String s5 = "123";   
16.  final String s6="12";  
17.  String s7=s6+"3";  
18.  System.err.println(s5 == s7);//true                     5                
19.  System.err.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*string\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");

编号1：String类型是一个很特殊的类型，当我们使用String str=”abc”;这种定义方法时，”abc”会放入常量池中，以后如果再有定义String str2=”abc”时，其实str和str2指向的是常量池中同一个对象。而只有当使用new创建时才会每次都创建一个新的对象。（我觉得这是String类型和其他类类型的特殊之处）

编号2、编号3：编号1已经分析了。

编号4：执行到  String c = b + "c"; 这一句时，java底层会先创建一个StringBuilder对象，封装b,接着再加上“c”，最后再创建一个String对象，将StringBuilder中的值赋给该String对象，用c来指向它。.其实此时的c指向的对象已经不是a指向的对象了。

编号5：当用final修饰后，s6就变为了常量，在常量池中创建“12”，当执行到String s7=s6+"3";时，编译器直接就把s6当成了“12”，s7此时就已是“123”，它指向常量池中的“123”，所以s5和s7指向的是同一个对象，输出为true。

**三、StringBuilder,StringBuffer,String的对比**

**(一)String**  
String类型的值是不可变的，听到这句话后可能你会有疑问，我们的String对象可以重新赋值呀，这里有两种情况，情况一：String str=”abc”; , 情况二：String str=new String(“abc”);采用情况一重新赋值时，java会先看常量池中有没有“abc”，如果有则直接指向它，如果没有，在编译时就创建一个常量放入常量池中；对于情况二：str则重新指向一个先创建的对象，该新对象在堆中。下面提出问题：为什么String是不可变的呢？我们来看看String的源码：

Java代码   ![收藏代码][icon_star.png]

1.  public final class String  
2.      implements java.io.Serializable, Comparable<String>, CharSequence  
3.  \{  
4.      /\*\* The value is used for character storage. \*/  
5.      private final char value\[\];  
6.    
7.      /\*\* The offset is the first index of the storage that is used. \*/  
8.      private final int offset;  
9.    
10.     /\*\* The count is the number of characters in the String. \*/  
11.     private final int count;  
12.   //••••••••••••••••••••

我们看到String类型是用一个用final修饰的char数组来存储字符串的，所以String类型是不可变的，（其实Short，Character，Long等包装类型也是这样实现的），根据上面对String类型的分析，如果要改变String的值，就要重新创建一个对象，这无疑性能会很差。为了优化String，sun公司添加了StringBuffer，在jdk1.5之后又添加了StringBuilder。

**（二）下面我们来分析一下StringBuffer**  
StringBuffer作为字符串缓冲类，当进行字符串拼接时，不会重新创建一个StringBuffer对象，而是直接在原有值后面添加，因为StringBuffer类继承了AbstractStringBuffer类，分析后者的源码后，我们发现存储字符串的char\[\]没有被final修饰。至于StringBuffer类是怎样扩充自己的长度的，我们可以参考它的append（）方法，这里不再赘述。不过一定要提出的是：StringBuffer是线程安全的，它的方法体是被synchronized修饰了的。

**（三）StringBuilder有是怎么样的呢？**  
StringBuilder基本实现了StringBuffer的功能，最大的不同之处在于StringBuilder不是线程安全的。

**（四）String、StringBuffer、StringBuilder的性能比较  
代码三：**

Java代码   ![收藏代码][icon_star.png]

1.                StringBuffer b = new StringBuffer("abc");  
2.  long t3 = System.currentTimeMillis();  
3.  for (int i = 0; i < 1000000; i++) \{  
4.      b = b.append("def");  
5.  \}  
6.  long t4 = System.currentTimeMillis();  
7.  System.out.println("1000000次拼接，StringBuffer所花时间为:" + (t4 - t3));  
8.  System.out.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
9.  StringBuilder c = new StringBuilder("abc");  
10. long t5 = System.currentTimeMillis();  
11. for (int i = 0; i < 1000000; i++) \{  
12.     c = c.append("def");  
13. \}  
14. long t6 = System.currentTimeMillis();  
15. System.out.println("1000000次拼接，StringBuilder所花时间为:" + (t6 - t5));  
16. System.out.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
17. String S1 = "abc";  
18. long t1 = System.currentTimeMillis();  
19. for (int i = 0; i < 10000; i++) \{  
20.     S1 += "def";  
21. \}  
22. long t2 = System.currentTimeMillis();  
23. System.out.println("10000次拼接，String所花时间为:" + (t2 - t1));

实验结果为：

Java代码   ![收藏代码][icon_star.png]

1.  1000000次拼接，StringBuffer所花时间为:203  
2.  \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
3.  1000000次拼接，StringBuilder所花时间为:79  
4.  \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
5.  10000次拼接，String所花时间为:640

显然，StringBuilder的性能最好，String的性能最差，而且差很多；不过StringBuffer的线程安全性很好，性能也比较接近StringBuilder,所以我推荐的选择使用顺序为：StringBuffer>StringBuilder>String;

**四、java传参**

下面我们我看一段代码，不过有点长，请大家有点耐心哦~  
**代码四：**

Java代码   ![收藏代码][icon_star.png]

1.  public class VariableTest \{  
2.  public static void main(String\[\] args) \{  
3.  VariableTest t = new VariableTest();  
4.          t.test();  
5.      \}  
6.    
7.      class Point \{  
8.          int x;  
9.          String y;  
10.         StringBuffer sb;  
11.                 public Point(int x, String y, StringBuffer sb) \{  
12.             this.x = x;  
13.             this.y = y;  
14.             this.sb = sb;  
15.         \}  
16.     \}  
17.   
18.     public void test() \{  
19.         int i = 1;  
20.         String str = "abc";  
21.         StringBuffer bs = new StringBuffer("abc");  
22.         Point p = new Point(1, "2", new StringBuffer("abc"));  
23.         System.out.println("\*\*\*\*\*\*\*\*\*\*\*函数调用之前\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
24.         System.out.println("i为：" + i);  
25.         System.out.println("str为：" + str);  
26.         System.out.println("bs为：" + bs);  
27.         System.out.println("p的x为：" + p.x + "         p的y为：" + p.y  
28.                 + "       p的sb为：" + p.sb);  
29.         change(i, str, bs, p);  
30.         System.out.println("\*\*\*\*\*\*\*\*\*\*\*函数调用之后\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
31.         System.out.println("i为：" + i);  
32.         System.out.println("str为：" + str);  
33.         System.out.println("bs为：" + bs);  
34.         System.out.println("p的x为：" + p.x + "         p的y为：" + p.y  
35.                 + "       p的sb为：" + p.sb);  
36.     \}  
37.   
38.     public void change(int p1, String p2, StringBuffer p3, Point p4) \{  
39.         p1 = 2;  
40.         p2 = "I have changed!";  
41.         p3 = p3.append("  I have changed!");  
42.         p4.x = 5;  
43.         p4.y = "I have changed!";  
44.         p4.sb = p4.sb.append("  I have changed!");  
45.     \}  
46.   
47. \}

输出结果为：

Java代码   ![收藏代码][icon_star.png]

1.  \*\*\*\*\*\*\*\*\*\*\*函数调用之前\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
2.  i为：1  
3.  str为：abc  
4.  bs为：abc  
5.  p的x为：1         p的y为：2       p的sb为：abc  
6.  \*\*\*\*\*\*\*\*\*\*\*函数调用之后\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
7.  i为：1  
8.  str为：abc  
9.  bs为：abc  I have changed!  
10. p的x为：5         p的y为：I have changed!       p的sb为：abc  I have changed!

[icon_star.png]: /images/20220805/e60fae501871476e8ed7059fd2345b63.png