1. String <--> Date

這種轉換要用到java.text.SimpleDateFormat類  
  
字符串轉換成日期類型：  
方法1：  
  
也是最簡單的方法 Date date=new Date("2008-04-14");  
  
方法2：  
  
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");//小寫的mm表示的是分鐘  
String dstr="2008-4-24";  
java.util.Date date=sdf.parse(dstr);  
  
  
  
日期轉換成字符串：  
  
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");  
java.util.Date date=new java.util.Date();  
String str=sdf.format(date);  
 

2. Iterable & Iterator

Iterator是叠代器類 Iterable是接口，
實現了Iterable就可以調用Iterator的方法  進而使用next hasNext方法  
當然也可以直接impemnts Iterator
那麽Iterable存在的必要？
Iterator接口的核心方法是next() hasNext() 是依賴於叠代器當前的叠代位置的
如果Collection直接實現Iterator接口勢必導致集合對象包含當前叠代位置的數據
(指針) 黨籍和在不同方法之間傳遞時，由於當前叠代位置不可預知，那麽next方法的結果變成不可預知
除非再為Iterator接口添加一個reset方法，用來重置當前叠代位置，
但即使這樣COllection也只能同時存在一個當前叠代位置
而Iterable則不然，每次調用都會返回一個從頭開始計數的叠代器
多個叠代器是互不幹擾的
 

3. String.contains源碼

String.contains(Charsequence)
1. abstract.contains(a)

2. indexof(a.toString) > -1

3. indexof(a, 0)

4. indexof(value, 0, value.length, str.value, 0, str.value.length, fromIndex)

5. value是一個字符數組 是String的內部實現

6. 
/*
 *   source   bstract
 *   sourceOffset  0
 *   sourceCount   7
 *   targetac
 *   targetOffset  0
 *   targetCount   2
 *   fromIndex 0
 * 
 */
    public int indexOf(char[] source, int sourceOffset, int sourceCount,
char[] target, int targetOffset, int targetCount,
int fromIndex) {
if (fromIndex >= sourceCount) {
return (targetCount == 0 ? sourceCount : -1);
}
if (fromIndex < 0) {
fromIndex = 0;
}
if (targetCount == 0) {
return fromIndex;
}

char first = target[targetOffset]; 
    //比方說bstract  找ac  你找到最後一個字母才找到a有什麽用呢  所以  最起碼你要在倒數第二個找到a  否則  就是找不到
int max = sourceOffset + (sourceCount - targetCount);
                        //第一個if失敗或者第二個if失敗  都會觸發i>max   然後返回-1  還有就是第一個匹配但是其他的不匹配
for (int i = sourceOffset + fromIndex; i <= max; i++) {
/* Look for first character. */
if (source[i] != first) {
while (++i <= max && source[i] != first);
}

/* Found first character, now look at the rest of v2 */
if (i <= max) { //判斷是否找見第一個字符
int j = i + 1;
int end = j + targetCount - 1;
for (int k = targetOffset + 1; j < end && source[j]
== target[k]; j++, k++);

        //只有第一個字符  要比較是否找到  其他的通過比較 j 是否進行到了end即可
if (j == end) {
/* Found whole string. */
return i - sourceOffset;
}
}
}
return -1;
}
 

4. final

final修飾的類有什麽特點

Java關鍵字final有“這是無法改變的”或者“終態的”含義，它可以修飾非抽象類、非抽象類成員方法和變量。

?final類不能被繼承，沒有子類，final類中的方法默認是final的。 


?final方法不能被子類的方法覆蓋，但可以被繼承。 


?final成員變量表示常量，只能被賦值一次，賦值後值不再改變。 


?final不能用於修飾構造方法。 

註意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。

final類

final類不能被繼承，因此final類的成員方法沒有機會被覆蓋，默認都是final的。在設計類時候，如果這個類不需要有子類，類的實現細節不允許改變，並且確信這個類不會載被擴展，那麽就設計為final類。

final方法

如果一個類不允許其子類覆蓋某個方法，則可以把這個方法聲明為final方法。使用final方法的原因有二：

①把方法鎖定，防止任何繼承類修改它的意義和實現。

②高效，編譯器在遇到調用final方法時候會轉入內嵌機制，大大提高執行效率。

例如：

public class Test1 { 
public static void main(String[] args) { 
// TODO 自動生成方法存根 
} 
public void f1() { 
System.out.println("f1"); 
} 
//無法被子類覆蓋的方法 
public final void f2() { 
System.out.println("f2"); 
} 
public void f3() { 
System.out.println("f3"); 
} 
private void f4() { 
System.out.println("f4"); 
} 
} 
public class Test2 extends Test1 { 
public void f1(){ 
System.out.println("Test1父類方法f1被覆蓋!"); 
} 
public static void main(String[] args) { 
Test2 t=new Test2(); 
t.f1(); 
t.f2(); //調用從父類繼承過來的final方法 
t.f3(); //調用從父類繼承過來的方法 
//t.f4(); //調用失敗，無法從父類繼承獲得 
} 
}

final變量（常量）

用final修飾的成員變量表示常量，值一旦給定就無法改變；

final修飾的變量有三種：靜態變量、實例變量和局部變量，分別表示三種類型的常量。

從下面的例子中可以看出，一旦給final變量初值後，值就不能再改變了。

package org.leizhimin; 
public class Test3 { 
private final String S="final實例變量S"; 
private final int A=100; 
public final int B=90; 
public static final int C=80; 
private static final int D=70; 
public final int E; //final空白,必須在初始化對象的時候賦初值 
public Test3(int x){ 
E=x; 
} 
/** 
* @param args 
*/ 
public static void main(String[] args) { 
Test3 t=new Test3(2); 
//t.A=101; //出錯,final變量的值一旦給定就無法改變 
//t.B=91; //出錯,final變量的值一旦給定就無法改變 
//t.C=81; //出錯,final變量的值一旦給定就無法改變 
//t.D=71; //出錯,final變量的值一旦給定就無法改變 
System.out.println(t.A); 
System.out.println(t.B); 
System.out.println(t.C); //不推薦用對象方式訪問靜態字段 
System.out.println(t.D); //不推薦用對象方式訪問靜態字段 
System.out.println(Test3.C); 
System.out.println(Test3.D); 
//System.out.println(Test3.E); //出錯,因為E為final空白,依據不同對象值有所不同. 
System.out.println(t.E); 
Test3 t1=new Test3(3); 
System.out.println(t1.E); //final空白變量E依據對象的不同而不同 
} 
private void test(){ 
System.out.println(new Test3(1).A); 
System.out.println(Test3.C); 
System.out.println(Test3.D); 
} 
public void test2(){ 
final int a; //final空白,在需要的時候才賦值 
final int b=4; //局部常量--final用於局部變量的情形 
final int c; //final空白,一直沒有給賦值. 
a=3; 
//a=4; 出錯,已經給賦過值了. 
//b=2; 出錯,已經給賦過值了. 
} 
}

另外，final變量定義的時候，可以先聲明，而不給初值，這中變量也稱為final空白，無論什麽

情況，編譯器都確保空白final在使用之前必須被初始化。但是，final空白在final關鍵字final

的使用上提供了更大的靈活性，為此，一個類中的final數據成員就可以實現依對象而有所不同，

卻有保持其恒定不變的特征。
final參數

當函數參數為final類型時，你可以讀取使用該參數，但是無法改變該參數的值。

public class Test4 { 
public static void main(String[] args) { 
new Test4().f1(2); 
} 
public void f1(final int i){ 
//i++; //i是final類型的,值不允許改變的. 
System.out.print(i); 
}

5. | & ||

|:邏輯或 不管怎樣都會執行左右兩邊

||: 斷言已經能判斷真假  就不需要往後繼續判斷或 
strId == null || strId.trim().equals("")

6. java.util.Date & mysql 0000-00-00 0:00:00

java.util.Date d = rs.getTImestamp("");

7. 程序優化

<1>常用邏輯抽象為方法
<2>常用變量聲明為final  可以用接口或者枚舉實現
<3>內部類  匿名類   外部類
<4>多態
<5>良好的註釋
<6>異常的處理  資源的關閉
<7>對象的聲明與銷毀
<8>問題的解決方案  線程  異步
<9>進階  設計模式 動態代理
<10>不要再一個類裏處理另一個類的邏輯   應該在另一個類封裝
<11>幾個類有相同的邏輯  定義抽象類  繼承
<12>   類內  static   不用每次用的時候都load進內存  
<13>根據用戶的需求 改變代碼 --->配置文件

8. 引用賦值問題

可以讓別人傳過來  也可以自己過去接受

9.Java中子類與父類的構造方法的調用關系

  在 Java 中，無論是 explicit 還是 implicit 方式，都要求在子類的構造方法中調用其父類的構造方法。如果父類無構造方法（其實是一個默認無參的構造方法），那麽子類的構造方法中會自動進行調用；如果 父類有自己的構造方法（這時父類不會有默認無參的構造方法），那麽在子類的構造方法中，必須要調用父類的某個構造方法，而且必須是在構造方法的第一個語句 中進行調用。

究其原因，想必是 Java 語言設計者，要求子類有責任保證它所繼承的父類盡快進入到一個穩定、完整的狀態中。試想，如果沒有這個約束，那麽子類的某個繼承自父類的方法可能會使用到父類中的一些變量，而這些變量並沒有進行初始化，從而產生一些難以預料的後果，因此構造子類的對象前，必須構造父類的對象，並將之隱含於子類對象之中，使用關鍵字super引用父類對象。

也因此，當一個類的構造方法是 private 時，它是不可被 extends 的，因為子類構造方法難以調用到這個父類的構造方法。

10 Java堆棧

• 內存分配的策略

  按照編譯原理的觀點,程序運行時的內存分配有三種策略,分別是靜態的,棧式的,和堆式的.

  　靜態存儲分配是指在編譯時就能確定每個數據目標在運行時刻的存儲空間需求,因而在編譯時就可以給他們分配固定的內存空間.這種分配策略要求程序代碼中不允許有可變數據結構(比如可變數組)的存在,也不允許有嵌套或者遞歸的結構出現,因為它們都會導致編譯程序無法計算準確的存儲空間需求.

  　棧式存儲分配也可稱為動態存儲分配,是由一個類似於堆棧的運行棧來實現的.和靜態存儲分配相反,在棧式存儲方案中,程序對數據區的需求在編譯時是完全未知的,只有到運行的時候才能夠知道,但是規定在運行中進入一個程序模塊時,必須知道該程序模塊所需的數據區大小才能夠為其分配內存.和我們在數據結構所熟知的棧一樣,棧式存儲分配按照先進後出的原則進行分配。

  　靜態存儲分配要求在編譯時能知道所有變量的存儲要求,棧式存儲分配要求在過程的入口處必須知道所有的存儲要求,而堆式存儲分配則專門負責在編譯時或運行時模塊入口處都無法確定存儲要求的數據結構的內存分配,比如可變長度串和對象實例.堆由大片的可利用塊或空閑塊組成,堆中的內存可以按照任意順序分配和釋放.

• 堆和棧的比較

上面的定義從編譯原理的教材中總結而來,除靜態存儲分配之外,都顯得很呆板和難以理解,下面撇開靜態存儲分配,集中比較堆和棧:

　從堆和棧的功能和作用來通俗的比較,堆主要用來存放對象的，棧主要是用來執行程序的.而這種不同又主要是由於堆和棧的特點決定的:

　在編程中，例如C/C++中，所有的方法調用都是通過棧來進行的,所有的局部變量,形式參數都是從棧中分配內存空間的。實際上也不是什麽分配,只是從棧頂向上用就行,就好像工廠中的傳送帶(conveyor belt)一樣,Stack Pointer會自動指引你到放東西的位置,你所要做的只是把東西放下來就行.退出函數的時候，修改棧指針就可以把棧中的內容銷毀.這樣的模式速度最快,當然要用來運行程序了.需要註意的是,在分配的時候,比如為一個即將要調用的程序模塊分配數據區時,應事先知道這個數據區的大小,也就說是雖然分配是在程序運行時進行的,但是分配的大小多少是確定的,不變的,而這個"大小多少"是在編譯時確定的,不是在運行時.

　 堆是應用程序在運行的時候請求操作系統分配給自己內存，由於從操作系統管理的內存分配,所以在分配和銷毀時都要占用時間，因此用堆的效率非常低.但是堆的優點在於,編譯器不必知道要從堆裏分配多少存儲空間，也不必知道存儲的數據要在堆裏停留多長的時間,因此,用堆保存數據時會得到更大的靈活性。事實上,面向對象的多態性,堆內存分配是必不可少的,因為多態變量所需的存儲空間只有在運行時創建了對象之後才能確定.在C++中，要求創建一個對象時，只需用new命令編制相關的代碼即可。執行這些代碼時，會在堆裏自動進行數據的保存.當然，為達到這種靈活性，必然會付出一定的代價:在堆裏分配存儲空間時會花掉更長的時間！這也正是導致我們剛才所說的效率低的原因,看來列寧同誌說的好,人的優點往往也是人的缺點,人的缺點往往也是人的優點(暈~).

• JVM中的堆和棧

JVM是基於堆棧的虛擬機.JVM為每個新創建的線程都分配一個堆棧.也就是說,對於一個Java程序來說，它的運行就是通過對堆棧的操作來完成的。堆棧以幀為單位保存線程的狀態。JVM對堆棧只進行兩種操作:以幀為單位的壓棧和出棧操作。

　　 我們知道,某個線程正在執行的方法稱為此線程的當前方法.我們可能不知道,當前方法使用的幀稱為當前幀。當線程激活一個Java方法,JVM就會在線程的Java堆棧裏新壓入一個幀。這個幀自然成為了當前幀.在此方法執行期間,這個幀將用來保存參數,局部變量,中間計算過程和其他數據.這個幀在這裏和編譯原理中的活動紀錄的概念是差不多的.

　　 從Java的這種分配機制來看,堆棧又可以這樣理解:堆棧(Stack)是操作系統在建立某個進程時或者線程(在支持多線程的操作系統中是線程)為這個線程建立的存儲區域，該區域具有先進後出的特性。

　 每一個Java應用都唯一對應一個JVM實例，每一個實例唯一對應一個堆。應用程序在運行中所創建的所有類實例或數組都放在這個堆中,並由應用所有的線程共享.跟C/C++不同，Java中分配堆內存是自動初始化的。Java中所有對象的存儲空間都是在堆中分配的，但是這個對象的引用卻是在堆棧中分配,也就是說在建立一個對象時從兩個地方都分配內存，在堆中分配的內存實際建立這個對象，而在堆棧中分配的內存只是一個指向這個堆對象的指針(引用)而已。

11 Java加載順序

先類的靜態初始化，再實例初始化，最後執行構造方法。也就是說，靜態初始化是屬於類加載的過程，所以它只執行一次，而實例初始化是每個對象創建時都會執行一次，而構造方法跟實例初始化其實也差不多，不過它在實例初始化之後執行，而且構造方法可以重載多個，執行哪個構造方法是根據你的選擇來的。

12 StringBuilder的清空

StringBuilder 沒有提供clear或empty方法。

清空有3種方法：

1）新生成一個，舊的由系統自動回收

2）使用delete

3）使用setLength

將三種方法循環1000萬次，代碼：

 1.public class sbbm {

2.

3.static String a;

4.static long time ;

5.public static void main( String[] args ) throws Exception {

6.   

7. StringBuilder sb = new StringBuilder();

8. StringBuilder sb3 = new StringBuilder();

9.

10. time = System.currentTimeMillis();

11.  for( int i = 0; i < 10000000; i++ ) {

12.  StringBuilder sb2 = new StringBuilder();

13.  sb2.append( "someStr6ing" );

14.  sb2.append( "someS5tring2" );

15.  sb2.append( "some3Strin4g" );

16.  sb2.append( "so3meStr5ing" );

17.  sb2.append( "so2meSt7ring" );

18.  a = sb2.toString();

19.  }

20.  System.out.println( "Way2="+(System.currentTimeMillis()-time) );

21.  

22.

23.time = System.currentTimeMillis();

24.for( int i = 0; i < 10000000; i++ ) {

25.sb.delete( 0, sb.length() );

26.sb.append( "someString" );

27.sb.append( "someString2" );

28.sb.append( "someStrin4g" );

29.sb.append( "someStr5ing" );

30.sb.append( "someSt7ring" );

31.a = sb.toString();

32.}

33.System.out.println( "Way1="+(System.currentTimeMillis()-time) );

34.

35.time = System.currentTimeMillis();

36.for( int i = 0; i < 10000000; i++ ) {

37.

38.sb3.setLength( 0 );

39.sb3.append( "someStr55ing" );

40.sb3.append( "some44String2" );

41.sb3.append( "som55eStrin4g" );

42.sb3.append( "some66Str5ing" );

43.sb3.append( "so33meSt7ring" );

44.a= sb3.toString() ;

45.}

46.System.out.println( "Way3="+(System.currentTimeMillis()-time) );

47. 

48. 

49.}

50.}