int,Integer,String,StringBuild,StringBuffer之谜

1. int与 Integer:

突然发现自己对Integer i = 10;这种语法不太明白，于是乎有了这篇文章，那么在讲解 Integer 之前，我们先看下面这段代码：  
public static void main(String[] args) {
    Integer i = 10;
    Integer j = 10;
    System.out.println(i == j);
      
    Integer a = 128;
    Integer b = 128;
    System.out.println(a == b);
     
    int k = 10;
    System.out.println(k == i);
    int kk = 128;
    System.out.println(kk == a);
      
    Integer m = new Integer(10);
    Integer n = new Integer(10);
    System.out.println(m == n);
}

大家可以先思考一下结果是什么？

答案是：

true,false,true,true,false

至于为什么是这个结果，下面我们来一一介绍。
1、Integer 类简介

首先我们大致看一下Integer是什么，Integer 类在JDK1.0的时候就有了，它是一个类，是 int 基本数据类型的封装类。
2、Integer 类和 int 的区别

①、Integer 是 int 包装类，int 是八大基本数据类型之一（byte,char,short,int,long,float,double,boolean）

②、Integer 是类，默认值为null，int是基本数据类型，默认值为0；

③、Integer 表示的是对象，用一个引用指向这个对象，而int是基本数据类型，直接存储数值。
3、Integer 的自动拆箱和装箱

自动拆箱和自动装箱是 JDK1.5 以后才有的功能，也就是java当中众多的语法糖之一，它的执行是在编译期，会根据代码的语法，在生成class文件的时候，决定是否进行拆箱和装箱动作。
①、自动装箱

一般我们创建一个类的时候是通过new关键字，比如：
  
Object obj = new Object();

但是对于 Integer 类，我们却可以这样：
Integer a = 128;

为什么可以这样，通过反编译工具，我们可以看到，生成的class文件是：
Integer a = Integer.valueOf(128);

这就是基本数据类型的自动装箱，128是基本数据类型，然后被解析成Integer类。
②、自动拆箱

我们将 Integer 类表示的数据赋值给基本数据类型int，就执行了自动拆箱。
Integer a = new Integer(128);
int m = a;

反编译生成的class文件：
    
Integer a = new Integer(128);
int m = a.intValue();

简单来讲：自动装箱就是Integer.valueOf(int i);自动拆箱就是 i.intValue();
4、回顾开头的问题
public static void main(String[] args) {
    Integer i = 10;
    Integer j = 10;
    System.out.println(i == j);
      
    Integer a = 128;
    Integer b = 128;
    System.out.println(a == b);
     
    int k = 10;
    System.out.println(k == i);
    int kk = 128;
    System.out.println(kk == a);
      
    Integer m = new Integer(10);
    Integer n = new Integer(10);
    System.out.println(m == n);
}

我们使用反编译工具Jad，得到的代码如下：
public static void main(String args[])
{
    Integer i = Integer.valueOf(10);
    Integer j = Integer.valueOf(10);
    System.out.println(i == j);
    Integer a = Integer.valueOf(128);
    Integer b = Integer.valueOf(128);
    System.out.println(a == b);
    int k = 10;
    System.out.println(k == i.intValue());
    int kk = 128;
    System.out.println(kk == a.intValue());
    Integer m = new Integer(10);
    Integer n = new Integer(10);
    System.out.println(m == n);
}

打印结果为：true,false,true,true,false

首先，直接声明Integer i = 10，会自动装箱变为Integer i = Integer.valueOf(10)；Integer i 会自动拆箱为 i.intValue()。

①、第一个打印结果为 true

对于 i == j ,我们知道这是两个Integer类，他们比较应该是用equals，这里用==比较的是地址，那么结果肯定为false，但是实际上结果为true，这是为什么？

我们进入到Integer 类的valueOf()方法：

分析源码我们可以知道在 i >= -128 并且 i <= 127 的时候，第一次声明会将 i 的值放入缓存中，第二次直接取缓存里面的数据，而不是重新创建一个Ingeter 对象。那么第一个打印结果因为 i = 10 在缓存表示范围内，所以为 true。

②、第二个打印结果为 false

从上面的分析我们知道，128是不在-128到127之间的，所以第一次创建对象的时候没有缓存，第二次创建了一个新的Integer对象。故打印结果为false

③、第三个打印结果为 true

Integer 的自动拆箱功能，也就是比较两个基本数据类型，结果当然为true

④、第四个打印结果为 true

解释和第三个一样。int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比较。

⑤、第五个打印结果为 false

因为这个虽然值为10，但是我们都是通过 new 关键字来创建的两个对象，是不存在缓存的概念的。两个用new关键字创建的对象用 == 进行比较，结果当然为 false。
5、测试
Integer a = 1;
Integer b = 2;
Integer c = 3;
Integer d = 3;
 
Integer e = 321;
Integer f = 321;
 
Long g = 3L;
Long h = 2L;
 
System.out.println(c == d);
System.out.println(e == f);
System.out.println(c == (a + b));
System.out.println(c.equals((a+b)));
System.out.println(g == (a+b));
System.out.println(g.equals(a+b));
System.out.println(g.equals(a+h));

反编译结果：

 

打印结果为：
  
true
false
true
true
true
false
true

分析：第一个和第二个结果没什么疑问，Integer类在-128到127的缓存问题；

第三个由于  a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法）,==比较符又将左边的自动拆箱，因此它们比较的是数值是否相等。

第四个对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。

第五个对于 g == (a+b)，首先计算 a+b,也是先调用各自的intValue方法，得到数值之后，由于前面的g是Long类型的，也会自动拆箱为long，==运算符能将隐含的将小范围的数据类型转换为大范围的数据类型，也就是int会被转换成long类型，两个long类型的数值进行比较。

第六个对于 g.equals(a+b),同理a+b会先自动拆箱，然后将结果自动装箱，需要说明的是 equals 运算符不会进行类型转换。所以是Long.equals(Integer)，结果当然是false

第七个对于g.equals(a+h),运算符+会进行类型转换，a+h各自拆箱之后是int+long，结果是long，然后long进行自动装箱为Long，两个Long进行equals判断。

2. String,StringBuild,StringBuffer:

2.1 区别：

      String是可变的， String使用字符数组保存字符串，该字符数组用final修饰了，是不可变的

      StringBuffer 和StringBuild 是可变的，而StringBuffer 是线程安全的，使用了synchronized同步锁，StringBuild是非线程安全的，一般情况下，如果单线程，字符串经常进行连接操作，可使用StringBuild的效率更高。

2.2：Java中以下两句有什么区别呢？
         String str1="abc";  
         String str2=new String("abc");

String s = new String("xxx")在检查常量池的时候会涉及到堆中创建对象；String s = "x"直接检查常量池，不会涉及堆。

String s1 = new String("1"); 是在堆中创建一个String对象，并检查常量池中是否有字面量为"1"的常量，没有的话在常量区创建"1"并将堆中的对象指向该常量,有的话堆中的对象直接指向"1"；

String s2 = new String("1"); 又在堆中创建一个String对象，并将s2指向该对象,其字面量"1"在前面已经创建，所以不会再创建常量区中创建字符串；

String s3 = "1";   检查常量池中有没有字面量为"1"的字符串，如果没有则创建并将s3指向该常量；有的话直接指向该该常量；

String s4 = "1"  的时候常量池已经有1，所以不会再创建对象，也就是s3与s4指向同一个对象。

 

总结：

1. 整形：装箱时valueOf注意IntegerCash缓存： i >= -128 并且 i <= 127

2.字符串：“abc”是存放在常量池中的，常量池在JVM中属于方法区，方法区和栈是两个概念。即常量池，堆内存，虚拟机栈三个是分开的。另外，new String("abc")时，JVM也首先回去常量池中查看是否有“abc”这个常量字符串，如果没有，也会创建这个常量字符串，然后在堆中为String对象分配空间。除此之外，堆内存的String对象中保存的也是“abc”在常量池中的地址引用，而不是“abc”