JVM常见面试题

一 什么是内存溢出，内存泄漏

      :当一个对象已经不需要再使用本该被回收时，另外一个正在使用的对象持有它的引用从而导致它不能被回收，这导致本该被回收的对象不能被回收而停留在堆内存中，这时候产生内存泄漏，

让我们来看看下面这个例子，看看为什么内存泄漏会发生。在如下例子中，对象A引用了对象B。A的生命周期（t1—t4）要比B的生命周期（t2—t3）长很多。当B不再用于应用中时，A仍然持有对它的引用。在这种方式下，垃圾回收器就不能将B从内存中移除。这将可能导致出现内存不足的问题，因为如果A对更多的对象做同样的事情，那么内存中将会有很多无法被回收的对象，这将极度耗费内存空间。

也有可能B持有大量对其他对象的引用，这些被B引用的对象也不能够被回收。所有这些未被使用的对象将会耗费宝贵的内存空间。

一次内存泄漏似乎不会有大的影响，但内存泄漏堆积后的后果就是内存溢出。

二.如何阻止内存泄漏？

（1）注意集合类，例如HashMap，ArrayList，等等。因为它们是内存泄漏经常发生的地方。当它们被声明为静态时，它们的生命周期就同应用程序的生命周期一般长。在退出程序之前，将集合里的东西clear，然后置为null，再退出程序。

（2）注意事件监听器和回调，如果一个监听器已经注册，但是当这个类不再被使用时却未被注销，就会发生内存泄漏。当它不再被使用的时候，需要注销该listener，

（3）“如果一个类管理它自己的内存，程序员应该对内存泄漏保持警惕。”[1] 很多时候当一个对象的成员变量指向其他对象时，不再使用时需要被置为null。

三 String类与常量池

1 String 对象的两种创建方式

String str1 = "abcd";
String str2 = new String("abcd");
System.out.println(str1==str2);//false

这两种不同的创建方法是有差别的，第一种方式是在常量池中拿对象，第二种方式是直接在堆内存空间创建一个新的对象。

2 String 类型的常量池比较特殊。它的主要使用方法有两种：

• 直接使用双引号声明出来的 String 对象会直接存储在常量池中。
• 如果不是用双引号声明的 String 对象，可以使用 String 提供的 intern 方法。String.intern() 是一个 Native 方法，它的作用是：如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用；如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用

	      String s1 = new String("计算机");
		String s2 = s1.intern();
		String s3 = "计算机";
		String s4 = new String("计算机");
		String s5 = s4.intern();
		System.out.println(s2);// 计算机
		System.out.println(s1 == s2);// false，因为一个是堆内存中的String对象一个是常量池中的String对象，
		System.out.println(s3 == s2);// true，因为两个都是常量池中的String对象
		System.out.println(s1 == s4);// false 两个都是堆中的String对象，但是内存地址不一样
		System.out.println(s2 == s5);// true
		// 运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用；
		// 所以s2与s5是同一个

3 String 字符串拼接

String str1 = "str";
String str2 = "ing";
 
String str3 = "str" + "ing";//常量池中的对象
String str4 = str1 + str2; //在堆上创建的新的对象     
String str5 = "string";//常量池中的对象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false

尽量避免多个字符串拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用 StringBuilder 或者 StringBuffer。

String s1 = new String("abc"); // 这句话创建了几个对象？

创建了两个对象

验证：

String s1 = new String("abc");// 堆内存的地值值
String s2 = "abc";
System.out.println(s1 == s2);// 输出false,因为一个是堆内存，一个是常量池的内存，故两者是不同的。
System.out.println(s1.equals(s2));// 输出true

解释：

先有字符串 “abc” 放入常量池，然后 new 了一份字符串 “abc” 放入 Java 堆（字符串常量 “abc” 在编译期就已经确定放入常量池，而 Java 堆上的 “abc” 是在运行期初始化阶段才确定），然后 Java 栈的 str1 指向 Java 堆上的 “abc”。

注意：这里还可能是只创建了一个对象，如果之前已经在常量池创建过“abc“字符串常量了，那此时就不再常量池中创建对象

四 StringBuilder

在jdk1.7中

      String str1=new StringBuilder("计算机").append("软件").toString();
      System.out.println(str1.intern()==str1);

      String str2=new StringBuilder("ja").append("va").toString();
      System.out.println(str2.intern()==str2);

此时返回结果为true与false

解释：在jdk1.7中，在常量池中记录首次出现的实例引用，因此intern()返回的引用和由StringBuilder创建的字符串实例是同一个，对Str2返回false是因为”java“字符串在执行StringBuilder()之前已经出现过，具体可以参考StringBuilder源码。字符串常量池已经有它的引用了，所以不符合首次出现。可以在创建Str1前加一个String s=new String("计算机软件");，此时就由true变为false

接着再来一道题：

String str1=new StringBuilder("计算机软件").toString();
System.out.println(str1.intern()==str1);

结果是多少呢？

应该会有人会觉得是true，被上面的String str1=new StringBuilder("计算机").append("软件").toString();迷惑了。其实这里输出false，原因听咋慢慢道来。

首先我们要知道字符串常量 “计算机软件” 在编译期就已经确定放入常量池，然后再赋值给str1，str1不在常量池，因为常量池已经有“计算机软件”了，你用append的时候new StringBuilder("计算机").append("软件").toString();在new的时候常量池创建的是“计算机”和“软件”，然后赋值给str1的时候，常量池中没有“计算机软件”，所以这个时候的str1还不是常量池的，通过intern()把str1变成常量池的

四 8种基本类型的包装类和常量池

• Java 基本类型的包装类的大部分都实现了常量池技术，即 Byte、Short、Integer、Long、Character、Boolean；这5种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。
• 两种浮点数类型的包装类 Float、Double 并没有实现常量池技术。

Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出true
Integer i11 = 333;
Integer i22 = 333;
System.out.println(i11 == i22);// 输出false
Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出false

 

 

Integer 缓存源代码：

/**
 *此方法将始终缓存-128到127（包括端点）范围内的值，并可以缓存此范围之外的其他值。
 */
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

Integer i1=40；Java 在编译的时候会直接将代码封装成 Integer i1=Integer.valueOf(40); 从而使用常量池中的对象。应用场景：

1. Integer i1 = new Integer(40) ;这种情况下会创建新的对象。

Integer i1 = 40;
Integer i2 = new Integer(40);
System.out.println(i1==i2); //输出false

 

Integer 比较（==）更丰富的一个例子：

Integer i1 = 40;
Integer i2 = 40;
Integer i3 = 0;
Integer i4 = new Integer(40);
Integer i5 = new Integer(40);
Integer i6 = new Integer(0);

System.out.println("i1=i2   " + (i1 == i2));//true
System.out.println("i1=i2+i3   " + (i1 == i2 + i3));//true
System.out.println("i1=i4   " + (i1 == i4));//false
System.out.println("i4=i5   " + (i4 == i5));//false
System.out.println("i4=i5+i6   " + (i4 == i5 + i6));//true
System.out.println("40=i5+i6   " + (40 == i5 + i6));//true

语句 i4 == i5 + i6，因为 + 这个操作符不适用于 Integer 对象，首先 i5 和 i6 进行自动拆箱操作，进行数值相加，即 i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。