【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 會自動拆箱，進行值比較，因此，結果爲真。