【275天】我爱刷题系列（34）

叨叨两句

1. 又一次说服了本能自我，感性自我，加油！

牛客网——java专项练习014

1

有以下代码片段：（D）
String str1="hello";
String str2="he"+ new String("llo");
System.out.println(str1==str2);
请问输出的结果是：

A true
B 都不对
C null
D false

大神解析

  1）String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。
 
    2）String类底层是char数组来保存字符串的。
 
    对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象
 
 
 
    字符串常量池
 
 
    在class文件中有一部分来存储编译期间生成的字面常量以及符号引用，这部分叫做class文件常量池，在运行期间对应着方法区的运行时常量池。
 
    JVM为了减少字符串对象的重复创建，其维护了一个特殊的内存，这段内存被成为字符串常量池或者字符串字面量池
 
    工作原理
 
    当代码中出现字面量形式创建字符串对象时，JVM首先会对这个字面量进行检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，否则新的字符串对象被创建，然后将这个引用放入字符串常量池，并返回该引用。
 
    实现前提
 
    字符串常量池实现的前提条件就是Java中String对象是不可变的，这样可以安全保证多个变量共享同一个对象。如果Java中的String对象可变的话，一个引用操作改变了对象的值，那么其他的变量也会受到影响，显然这样是不合理的。
 
 
 
    String str1 = "hello";
 
    这里的str1指的是方法区中的字符串常量池中的“hello”，编译时期就知道的； 
 
    String str2 = "he" + new String("llo");
 
    这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串“hello”，所以这两个引用是不一样的。
 
    如果用str1.equal(str2)，那么返回的是true；因为String类重写了equals()方法。
 
    编译器没那么智能,它不知道"he" + new String("llo")的内容是什么,所以才不敢贸然把"hello"这个对象的引用赋给str2.
 
    如果语句改为:"he"+"llo"这样就是true了。
 
    new String("zz")实际上创建了2个String对象，就是使用“zz”通过双引号创建的（在字符串常量池），另一个是通过new创建的（在堆里）。只不过他们的创建的时期不同，一个是编译期，一个是运行期。
 
    String s = "a"+"b"+"c";
 
    语句中，“a”,"b", "c"都是常量，编译时就直接存储他们的字面值，而不是他们的引用，在编译时就直接将它们连接的结果提取出来变成"abc"了。
 

2

执行如下程序，输出结果是（ C ）

class Test
{

 private int data;
 int result = 0;
 public void m()
 {
     result += 2;
     data += 2;
     System.out.print(result + "  " + data);
 }

}
class ThreadExample extends Thread
{

 private Test mv;
 public ThreadExample(Test mv)
 {
     this.mv = mv;
 }
 public void run()
 {
     synchronized(mv)
     {
         mv.m();
     }
 }

}
class ThreadTest
{

 public static void main(String args[])
 {
     Test mv = new Test();
     Thread t1 = new ThreadExample(mv);
     Thread t2 = new ThreadExample(mv);
     Thread t3 = new ThreadExample(mv);
     t1.start();
     t2.start();
     t3.start();
 }

}

A 0 22 44 6
B 2 42 42 4
C 2 24 46 6
D 4 44 46 6

Test mv =newTest()声明并初始化对data赋默认值 
使用synchronized关键字加同步锁线程依次操作m() 
t1.start();使得result=2,data=2,输出即为2 2 
t2.start();使得result=4,data=4,输出即为4 4 
t3.start();使得result=6,data=6,输出即为6 6 
 System.out.print(result +" "+ data);是print()方法不会换行,输出结果为2 24 46 6

3

在jdk1.5的环境下，有如下4条语句：

Integer i01 = 59;
int i02 = 59;
Integer i03 =Integer.valueOf(59);
Integer i04 = new Integer(59)。
以下输出结果为false的是：

正确答案: C 你的答案: C (正确)

A System.out.println(i01== i02);
B System.out.println(i01== i03);
C System.out.println(i03== i04);
D System.out.println(i02== i04);

Integer i01=59 的时候，会调用 Integer 的 valueOf 方法，

  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 对象，只是在返回之前，看作了一个判断，判断当前 i 的值是否在 [-128,127] 区别，且 IntegerCache 中是否存在此对象，如果存在，则直接返回引用，否则，创建一个新的对象。
在这里的话，因为程序初次运行，没有 59 ，所以，直接创建了一个新的对象。
 
int i02=59 ，这是一个基本类型，存储在栈中。
 
Integer i03 =Integer.valueOf(59); 因为 IntegerCache 中已经存在此对象，所以，直接返回引用。
 
Integer i04 = new Integer(59) ；直接创建一个新的对象。
 
System. out .println(i01== i02); i01 是 Integer 对象， i02 是 int ，这里比较的不是地址，而是值。 Integer 会自动拆箱成 int ，然后进行值的比较。所以，为真。
 
System. out .println(i01== i03); 因为 i03 返回的是 i01 的引用，所以，为真。
 
System. out .println(i03==i04); 因为 i04 是重新创建的对象，所以 i03,i04 是指向不同的对象，因此比较结果为假。
 
System. out .println(i02== i04); 因为 i02 是基本类型，所以此时 i04 会自动拆箱，进行值比较，所以，结果为真。