String使用，int、Integer==和equal的关系

一、String

		String a="hello";
		String b=new String("hello");
		String c=new String("hello");
		
		System.out.println(a==b);		//false
		System.out.println(a.equals(b));  	//true
			
		System.out.println(b==c);		//false
		System.out.println(b.equals(c));	//true

　　1、从内存的角度看，“”==“”比较的是引用是否指向同一个堆内存地址

　　《深入理解java虚拟机》中描述，对象引用存放在栈中，即a,b,c都在栈中；对象实例，即new出来的对象实例存放在堆中；“hello”，是String类型数据，是final不可变量，存放在常量池中，且只有一个。

　　a直接指向常量池中的“String”，在堆中没有生成对象实例；b，c，是new出来的对象，分别在堆中划分出一块内存存放对象实例，即b，c引用分别先指向堆中各自生成的实例对象，实例对象再指向常量池中的“hello”；

　　“==”比较是的，2个引用是否指向同一个内存地址

　　a指向常量池中的“hello”，b指向堆中的实例对象，a!=b

　　b,c分别指向堆中的2块不同内存，b!=c

 

　　2、equal比较的是对象的“内容”是否相同

　　下面是String的equals源码，可以看出，比较的是每个字节是否相等，那"“hello”当然是相等的，a,b,c直接equals都是true

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

　二、int和Integer

　　Ingeter是int的包装类，int的初值为0，Ingeter的初值为null；

　　包装类和它的基本类型变量==比较时候，会自动拆箱，即包装类转换基本类型变量，比较两者的数值是否相等

　　

        int a=127;
        Integer b=new Integer(127);
        
        System.out.println(a==b);    //true
        System.out.println(b.equals(a));    //true

　　a==b，b是包装类，调用intValue()方法进行拆箱赋值，直接比较两者值是相等的

　　Integer的源码equals，可以看出比较是数值是否相等

 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

三、Integer的缓存问题

这是Integer的源码，可以看出，-128~127之间，会转成Integer.valueOf(xxx)，写入缓存，第二次写入就是用缓存中的值

    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 a=127;
		Integer b=127;

		System.out.println(a==b);	//true
		
		Integer d=128;
		Integer e=128;
		
		System.out.println(d==e);	//false

　　a,b,c,d自动装箱成Integer类型

　　在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，始终只存在一个对象。

　　而如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个 Integer对象；

 

第一次写博客，写的不清楚希望原谅