Java面试重点_1. 常量池 和 String类的不变性, 拼接方式等 0.8

																																																																										# 一, 常量池

1. 常量池的好处

常量池是为了避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。
例如字符串常量池，在编译阶段就把所有的字符串文字放到一个常量池中。
（1）节省内存空间：常量池中所有相同的字符串常量被合并，只占用一个空间。
（2）节省运行时间：比较字符串时，比equals()快。对于两个引用变量，只用判断引用是否相等，也就可以判断实际值是否相等。

2. 双等号 ==, equals();

• 在基本数据类型中使用==表示比较他们的数值大小, 在引用数据类型的对象之间, ==是比较他们的地址是否相同;
• equals() 原本是用来比较两个引用数据类型之间的地址是否相同, 但是在 String类, Date类, Integer类中发生了重写, 用来比较他们的字面量值是否相等;

二, 8种基本数据类型的包装池和常量池

1. Java中基本数据类型的包装类的大部分都实现了常量池技术, 即Byte, Short, Integer, Long, Character, Boolean;

Integer i1 = 40;
Integer i2 = 40;
System.out.println("i1 == i2");//自动拆箱, 输出True; 

这5中包装类默认借助常量池缓存数值为[-128,127]的数据, 但是超出此范围的数据仍旧会创建新的对象;

在Java中，会对-128到127的Integer对象进行缓存，当创建新的Integer对象时，如果符合这个这个范围，并且已有存在的相同值的对象，则返回这个对象，否则创建新的Integer对象。

//Integer 缓存代码 ：
public static Integer valueOf(int i) {
    
    
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

Integer i1 = 400;
Integer i2 = 400;
System.out.println(i1 == i2); //输出false
//可能有人在这个例子会有疑惑, i1 == i2 比较不就自动拆箱了吗?   
//其实不是的, 一个包装类对象(引用数据类型)和一个基本数据类型比较的话, 这个包装类对象才会发生拆箱, 比如此题 i1 == 400 的判断, 肯定是true的;
//而两个包装类对象之间使用 == 比较, 不会拆箱噢!  直接比较地址值!!!!!!!,  所以这里 i1 == i2, 比较的就是地址值, 而由于两者数值都超出了缓存池的缓存范围, 都会被新建对象, 所以地址是肯定不相等的! 返回的就是false;  

2. 两种浮点数类型的包装类Float,Double并没有实现常量池技术。

   Double i1=1.2;
   Double i2=1.2;
   System.out.println(i1==i2);//输出false

3. 应用常量池的场景

   • Integer i1=40；Java在编译的时候会直接将代码封装成Integer i1=Integer.valueOf(40);，从而使用常量池中的对象。
   • Integer i1 = new Integer(40);这种情况下会创建新的对象。

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

4. 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对象( + 这个字符对Integer来说是非常困惑的, 所以Integer会发生自动拆箱, 使用基本数据类型进行 + 计算，首先i5和i6进行自动拆箱操作，进行数值相加，即i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。

• 扩展阅读: Java中的自动装箱与拆箱

三, String类和常量池

1. String类的不变性?

• 必须掌握: String类的不变性和 不变性的优点

2. String 对象创建方式

String str1 = "abcd";
String str2 = new String("abcd");

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

3. 连接表达式 +

1. 只有使用引号包含文本的方式创建的String对象, 这些对象之间使用"+"连接产生的新对象才会被加入字符串池中;
2. 对于所有包含new方式新建对象(包括null), 这些对象之间使用"+"连接产生的新对象, 都不会被加入到字符串池中;
3. 常量与常量的拼接操作, 结果是放在常量池, 但是一定要注意!! --> 如果拼接符号+的前后出现了变量, 则相当于在堆空间中 new String(),

  String str1 = "str";
  String str2 = "ing";
  
  String str3 = "str" + "ing";
  String str4 = str1 + str2;
  System.out.println(str3 == str4);//false
  
  String str5 = "string";
  System.out.println(str3 == str5);//true

• 特例:

public static final String A = "ab"; // 常量A
public static final String B = "cd"; // 常量B
public static void main(String[] args) {
    
    
     String s = A + B;  // 将两个常量用+连接对s进行初始化 
     String t = "abcd";   
    if (s == t) {
    
       
         System.out.println("s等于t，它们是同一个对象");   
     } else {
    
       
         System.out.println("s不等于t，它们不是同一个对象");   
     }   
 } 
s等于t，它们是同一个对象

A和B都是常量(都是被final修饰了的)，值是固定的，因此s的值也是固定的，它在类被编译时就已经确定了。也就是说：String s=A+B; 等同于：String s=“ab”+“cd”;

• 特例2:

public static final String A; // 常量A
public static final String B;    // 常量B
static {
    
       
     A = "ab";   
     B = "cd";   
 }   
 public static void main(String[] args) {
    
       
    // 将两个常量用+连接对s进行初始化   
     String s = A + B;   
     String t = "abcd";   
    if (s == t) {
    
       
         System.out.println("s等于t，它们是同一个对象");   
     } else {
    
       
         System.out.println("s不等于t，它们不是同一个对象");   
     }   
 } 
s不等于t，它们不是同一个对象

A和B虽然被定义为常量，但是它们都没有马上被赋值。在运算出s的值之前，他们何时被赋值，以及被赋予什么样的值，都是个变数。因此A和B在被赋值之前，性质类似于一个变量。那么s就不能在编译期被确定，而只能在运行时被创建了。

3.1 + 的原理

为什么说 ‘+’ 很糟糕?

3.2 如何取代循环中比较糟糕的 + ?

• 参考文章:
  • 重要: 必读—>52.String内存结构位置和String拼接操作(面试)
  • https://www.jianshu.com/p/c7f47de2ee80
  • Java字符串拼接的优雅方式

四, new String()会创建几个对象？

深入阅读: new String()创建几个对象？