摘要：網(wǎng)站的面試專題學(xué)習(xí)筆記非可變性和對象引用輸出為，前后皆有空格。假定棧空間足夠的話，盡管遞歸調(diào)用比較難以調(diào)試，在語言中實現(xiàn)遞歸調(diào)用也是完全可行的。棧遵守規(guī)則，因此遞歸調(diào)用方法能夠記住調(diào)用者并且知道此輪執(zhí)行結(jié)束之返回至當(dāng)初的被調(diào)用位置。

ImportNew 網(wǎng)站的Java面試專題學(xué)習(xí)筆記

String s = " Hello ";
s += " World ";
s.trim( );
System.out.println(s);

輸出為“ Hello World ”，前后皆有空格。
字符串是不可變對象。
s.trim()雖然生成了一個新的字符串對象，但是卻沒有變量指向這個心生成的對象，s 仍然指向字符串s += " World "。
下圖說明了，生成對象以及垃圾回收過程。

可用StringBuilder來構(gòu)造，因為其底層使用的是字符數(shù)組，所有操作都直接在字符數(shù)組上直接操作，而且他不是一個線程安全的類，執(zhí)行速度上，相比于StringBuffer要快。

這一點如果深入理解了String的Interning機制，就更好理解了。
Java程序在編譯時，會將所有確定下來的，存在雙引號內(nèi)的字符串，都存入常量池中，該常量池是類文件(.class)的一部分。常量池中存著許多表，其中 Constant_Utf8_info 表中，記錄著會被初始化為 String 對象的字符串的字面值（iteral）。 在JVM 中，相應(yīng)的類被加載運行后，常量池對應(yīng)的映射到 JVM 的運行時常量池（run time constant pool）中。

關(guān)于String的intern()方法

當(dāng) intern 方法被調(diào)用，如果字符串池中已經(jīng)擁有一個與該 String 的字符串值相等（即 equals()調(diào)用后為 true）的 String 對象時，那么池中的那個 String 對象會被返回。否則，池中會增加這個對象，并返回當(dāng)前這個 String 對象。

現(xiàn)代的 JVM 實現(xiàn)里，考慮到垃圾回收（Garbage Collection）的方便，將 heap 劃分為三部分： young generation 、 tenured generation（old generation）和 permanent generation( permgen )。字符串池是為了解決字符串重復(fù)的問題，生命周期長，它存在于 permgen 中。

因此，對于

String str = new String("abc");

JVM會生成兩個字符串，一個是在常量池中，另外一個是new在heap堆中。

Object s1 = new String("Hello");
Object s2 = new String("Hello");
 
if(s1 == s2) {
  System.out.println("s1 and s2 are ==");
}else if (s1.equals(s2)) {
  System.out.println("s1 and s2 are equals()");
}

輸出結(jié)果為s1 and s2 are equals()
主要考察對equals和==的理解，==比較引用的地址是否相同，equeal比較對象中真正的值。
詳細(xì)的過程可見下圖

另外，如果不是用 new關(guān)鍵字強制創(chuàng)建字符串對象的話，而是采用==，那么Java會默認(rèn)采用字符串池，減少對象的創(chuàng)建。

String對象會創(chuàng)建一個字符串池（a pool of string），如果當(dāng)前準(zhǔn)備新創(chuàng)建的字符串對象的值在這個池子中已經(jīng)存在，那么就不會生成新對象，而是復(fù)用池中已有的字符串對象。flyweight 模式的精髓就是對象復(fù)用。

重寫發(fā)生在子類繼承父類時，子類覆蓋父類的方法時發(fā)生，是在運行時發(fā)生。
重載是在同一個類中，同一個方法，不同參數(shù)時發(fā)生，是在編譯期發(fā)生。

在Java 5中使用注解@override，來標(biāo)示方法重寫，如果編譯時發(fā)現(xiàn)沒有重寫，則JVM會拋出編譯異常。

可重入方法（re-entrant method）是可以安全進入的方法，即使同一個方法正在被執(zhí)行，深入到同一個線程的調(diào)用棧里面也不會影響此次執(zhí)行的安全性。一個非可重入方法則不是可以安全進入的。例如，加入寫文件或者向文件中寫入日志的方法不是可重入方法時，有可能會毀壞那個文件。

如果一個方法調(diào)用了其自身的話，我們稱之為遞歸調(diào)用。假定?？臻g足夠的話，盡管遞歸調(diào)用比較難以調(diào)試，在Java語言中實現(xiàn)遞歸調(diào)用也是完全可行的。遞歸方法是眾多算法中替代循環(huán)的一個不錯選擇。所有的遞歸方法都是可重入的，但是不是所有可重入的方法都是遞歸的。

棧遵守LIFO（Last In First Out）規(guī)則，因此遞歸調(diào)用方法能夠記住“調(diào)用者”并且知道此輪執(zhí)行結(jié)束之返回至當(dāng)初的被調(diào)用位置。遞歸利用系統(tǒng)棧來存儲方法調(diào)用的返回地址。 Java是一種基于棧設(shè)計的編程語言。

循環(huán)的方式可以達到目的，不必采用遞歸。但是在某些情況下采用遞歸方式則代碼會更加簡短易讀。遞歸方法在循環(huán)樹結(jié)構(gòu)以及避免丑陋的嵌套循環(huán)的情況下是非常好用的。

常規(guī)遞歸方法（亦稱，頭遞歸）在上面演示了，這種方式會增加調(diào)用棧的大小。每次遞歸，其入口需要被記錄在棧中。方法返回之前需要給countA(input.substring(1)的結(jié)果加一個count。因此，最后需要做的事其實是加法運算，而非遞歸本身。

在尾遞歸中，最后要做的是遞歸，加法運算在之前就已經(jīng)完成了。棧調(diào)用減少帶來了內(nèi)存消耗減少并且程序的性能更好。如下代碼

public class TailRecursiveCall {
 
 public int countA(String input) {
 
  // exit condition – recursive calls must have an exit condition
  if (input == null || input.length() == 0) {
   return 0;
  }
 
  return countA(input, 0) ;
 }
 
 public int countA(String input, int count) {
  if (input.length() == 0) {
   return count;
  }
 
  // check first character of the input
  if (input.substring(0, 1).equals("A")) {
   count = count + 1;
  }
 
  // recursive call is the last call as the count is cumulative
  return countA(input.substring(1), count);
 }
 
 public static void main(String[] args) {
  System.out.println(new TailRecursiveCall().countA("AAA rating"));
 }
}

ArrayList的大小是如何自動增加的？你能分享一下你的代碼嗎？

使用ensureCapacity, 在進行添加元素時，檢查容量是否足夠，不夠的話，就將容量擴大3/2,并將舊數(shù)組中的元素使用Arrays.copyOf拷貝到新數(shù)組中。

什么情況下你會使用ArrayList？什么時候你會選擇LinkedList？

ArrayList是在訪問的次數(shù)遠(yuǎn)大于插入和刪除的次數(shù)，使用ArrayList,因為ArrayList底層使用數(shù)組，訪問的復(fù)雜度為O(1), 但是插入和刪除就得頻繁使用System.arraycopy復(fù)制數(shù)組。 LinkList主要在訪問次數(shù)遠(yuǎn)小于插入和刪除的次數(shù)時使用，其刪除和插入的復(fù)雜度,但訪問元素時幾乎為O(n)。

當(dāng)傳遞ArrayList到某個方法中，或者某個方法返回ArrayList，什么時候要考慮安全隱患？如何修復(fù)安全違規(guī)這個問題呢？

當(dāng)array被當(dāng)做參數(shù)傳遞到某個方法中，如果array在沒有被復(fù)制的情況下直接被分配給了成員變量，那么就可能發(fā)生這種情況，即當(dāng)原始的數(shù)組被調(diào)用的方法改變的時候，傳遞到這個方法中的數(shù)組也會改變。

將其副本拷貝出來再進行修改。

如何復(fù)制某個ArrayList到另一個ArrayList中去？寫出你的代碼？

使用clone()方法，比如ArrayList newArray = oldArray.clone();
使用ArrayList構(gòu)造方法，比如：ArrayList myObject = new ArrayList(myTempObject);
使用Collection的copy方法...

注意1和2是淺拷貝(shallow copy)，何為淺拷貝？

淺拷貝就比如像引用類型，而深拷貝就比如值類型。淺拷貝是指源對象與拷貝對象共用一份實體，僅僅是引用的變量不同（名稱不同）。對其中任何一個對象的改動都會影響另外一個對象。舉個例子，一個人一開始叫張三，后來改名叫李四了，可是還是同一個人，不管是張三缺胳膊少腿還是李四缺胳膊少腿，都是這個人倒霉。
深拷貝是指源對象與拷貝對象互相獨立，其中任何一個對象的改動都不會對另外一個對象造成影響。舉個例子，一個人名叫張三，后來用他克隆（假設(shè)法律允許）了另外一個人，叫李四，不管是張三缺胳膊少腿還是李四缺胳膊少腿都不會影響另外一個人。比較典型的就是Value（值）對象，如預(yù)定義類型Int32，Double，以及結(jié)構(gòu)（struct），枚舉（Enum）等。

還可用序列化技術(shù)來進行深拷貝，對象實現(xiàn)序列化接口，然后寫入流，并讀出來

// 將對象寫到流里
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);
        // 從流里讀出來
        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        return (oi.readObject());

但是串行化卻很耗時，在一些框架中，我們便可以感受到，它們往往將對象進行串行化后進行傳遞，耗時較多。

在索引中ArrayList的增加或者刪除某個對象的運行過程？效率很低嗎？解釋一下為什么？

頻繁插入和刪除，會頻繁調(diào)用System.arrayCopy....效率低

參考地址
-[1] http://www.importnew.com/2228...
-[2] http://www.importnew.com/2223...
-[3] http://www.importnew.com/2217...
-[4] http://www.importnew.com/2329...
-[5] http://www.importnew.com/9928...
-[6] http://www.cnblogs.com/shuaiw...
-[7] http://blog.csdn.net/biaobiao...