自动拆装箱的考题(自动拆装箱JDK需在1.5上）

自动拆装箱的考题(自动拆装箱JDK需在1.5上）

本题是一个自动拆装箱的考题(自动拆装箱JDK需在1.5上），下面的讨论都不针对新开辟对象的情况：

1、基本型和基本型封装型进行“”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

int a=257;
Integer b=257;
Integer c=257;
Integer b2=57;
Integer c2=57;
System.out.println(ab);
//System.out.println(a.equals(b)); 编译出错，基本型不能调用equals()
System.out.println(b.equals(257.0));
System.out.println(bc);
System.out.println(b2==c2);

因此上面的代码的结果因此为 true, false, false, true

==如果是primitive主类型，那么比较值；如果是对象，那么比较引用地址

equals需要根据具体对象的实现来判断，在Integer里面是判断值是否相等

解答三:

一般说来，如果是两个Integer类型进行比较，就是比较两个Integer对象的地址。但是有一点需要注意的是在-128至127这个区间，如果创建Integer对象的时候（1）Integer i = 1; （2） Integer i = Integer.valueOf(1); 如果是这两种情况创建出来的对象，那么其实只会创建一个对象，这些对象已经缓存在一个叫做IntegerCache里面了，所以比较是相等的。( 只有使用Integer.valueOf()这个函数（Integer i = 6这种也会默认调用valueOf函数），并且值在-128到127之间的才会有缓存，比较的地址也是一样的。 )

如果不在-128至127这个区间，不管是通过什么方式创建出来的对象，==永远是false，也就是说他们的地址永远不会相等。

从源码角度分析：自动装箱调用Integer i = Integer.valueOf(0)
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.***[i + (-IntegerCache.low)];
return new Integer(i);
}
自动拆箱调用Integer.intValue
public int intValue() {
return value;
}
正如楼主所说。
public void Test() {
Integer i1 = 0;
Integer i2 = 0;

Integer i3 = 200;
Integer i4 = 200;

// ==
System.out.println(i1 == i2);//true
System.out.println(i3 == i4);//false

// equals
System.out.println(i1.equals(i2));//true
System.out.println(i3.equals(i4));//true

}

---

层主是对的啊！！！

public class Test {
public static void main(String[] args) {
Integer a = 128;
Integer b = 128;
System.out.println(a == b);
Integer c = 127;
Integer d = 127;
System.out.println(c == d);
}
}第一个是false
第二个是true

---

、这个的自动装箱拆箱不仅在基本数据类型中有应用，在String类中也有应用，比如我们经常声明一个String对象时：

    String str = "sl";
    //代替下面的声明方式
    String str = new String("sl");

问题 String s = new String(“hello”)和String s = “hello”;的区别?

String的值都在方法区的常量池中，前者要在对中创建s对象和常量池中创建hello对象。后者只需要在常量池中创建hello对象； 前者会创建2个对象，后者创建1个对象。

看一下程序的结果：

public class St {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3 == s1 + s2);// false
        System.out.println(s3.equals((s1 + s2)));// true
        System.out.println(s3 == "hello" + "world");// true
        System.out.println(s3.equals("hello" + "world"));// true
       
    }
}

​ 字符串如果是变量相加，先开空间，在拼接。 字符串如果是常量相加，是先加，然后在常量池找，如果有就直接返回，否则，就创建。

---

此代码片段输出正确的值是（）

public class CharToString {
 public static void main(String[] args)
 {
  char myChar = 'g';
  String myStr = Character.toString(myChar);
  System.out.println("String is: "+myStr);
  myStr = String.valueOf(myChar);
  System.out.println("String is: "+myStr);
 }
}

正确答案: A 你的答案: C (错误)

A. String is: 
   gString is: g
B. String is: 
   103String is: g
C. String is: 
   gString is: 103
D. String is: 
   103String is: 103

//Character的源码
public static String toString(char c) { return String.valueOf(c);//char->String
}

//String类的源码 toString调用String.valueOf() valueOf重载 返回不同的值
public static String valueOf(int i) { return Integer.toString(i);//char->assic
}
public static String valueOf(char c) { char data[] = {c}; return new String(data, true);
}//char->String
//第一和第三返回的都是字符串,只有char变成 int 的时候才会变为对应的assic码

int a= 'a';
System.out.println(a);
//输出:97,字符可以赋值给int类型.
    

String.valueOf(myChar); //是将char类型的myChar转化成String类型