swzhebei

轉(zhuǎn)載：Spring MVC 3 深入總結(jié)

posted @ 2013-07-19 15:57 透明的魚 閱讀(920) | 評論 (0) | 編輯 收藏

刪除數(shù)據(jù)庫中重復(fù)的記錄

1.delete from 表名　where ID in (select id from 表名 group by id having count(id) >1)

　　and rowid not in (select min(rowid) from 表名 group by id having count(id )>1)

posted @ 2012-12-05 16:30 透明的魚 閱讀(255) | 評論 (0) | 編輯 收藏

使用POI對excel表數(shù)據(jù)進(jìn)行操作時出現(xiàn)了該問題

     解決辦法：

       判斷讀取的單元格是否為HSSFCell.CELL_TYPE_NUMERIC類型，然后利用cell.getNumericCellValue()，讀取該單元格的數(shù)據(jù)。

    getNumericCellValue()讀出的數(shù)據(jù)類型是double型，

   因此，需要重新進(jìn)行數(shù)據(jù)轉(zhuǎn)換：HSSFDateUtil.getJavaDate(d).toLocaleString()。其中d為讀出的double類型數(shù)據(jù)。

 至此，則成功的將excel表內(nèi)的數(shù)據(jù)讀取出來。

單元格的格式總共有以下幾種：

HSSFCell.CELL_TYPE_BLANK;
HSSFCell.CELL_TYPE_BOOLEAN;
HSSFCell.CELL_TYPE_ERROR;
HSSFCell.CELL_TYPE_FORMULA;
HSSFCell.CELL_TYPE_NUMERIC;
HSSFCell.CELL_TYPE_STRING;

posted @ 2012-09-25 09:48 透明的魚 閱讀(390) | 評論 (0) | 編輯 收藏

轉(zhuǎn)載：正則表達(dá)式學(xué)習(xí)---重復(fù)匹配

PS：在所有例子中正則表達(dá)式匹配結(jié)果包含在源文本中的【和】之間，有的例子會使用java來實(shí)現(xiàn)，如果是java本身正則表達(dá)式的用法，會在相應(yīng)的地方說明。所有java例子都在JDK1.6.0_13下測試通過。

一、有多少個匹配

         前面幾篇講的都是匹配一個字符，但是一個字符或字符集合要匹配多次，應(yīng)該怎么做呢？比如要匹配一個電子郵件地址，用之前說到的方法，可能有人會寫出像\w@\w\.\w這樣的正則表達(dá)式，但這個只能匹配到像a@b.c這樣的地址，明顯是不正確的，接下來就來看看如何匹配電子郵件地址。

         首先要知道電子郵件地址的組成：以字母數(shù)字或下劃線開頭的一組字符，后面跟@符號，再后面是域名，即用戶名@域名地址。不過這也跟具體的郵箱服務(wù)提供商有關(guān)，有的在用戶名中也允許.字符。

1、匹配一個或多個字符

         要想匹配同一個字符（或字符集合）的多次重復(fù)，只要簡單地給這個字符（或字符集合）加上一個+字符作為后綴就可以了。+匹配一個或多個字符（至少一個）。如：a匹配a本身，a+將匹配一個或多個連續(xù)出現(xiàn)的a；[0-9]+匹配多個連續(xù)的數(shù)字。

         注意：在給一個字符集合加上+后綴的時候，必須把+放在字符集合的外面，否則就不是重復(fù)匹配了。如[0-9+]這樣就表示數(shù)字或+號了，雖然語法上正確，但不是我們想要的了。

文本：Hello, mhmyqn@qq.com or mhmyqn@126.com is my email.

正則表達(dá)式：\w+@(\w+\.)+\w+

結(jié)果：Hello, 【mhmyqn@qq.com】 or 【mhmyqn@126.com】 is my email.

分析：\w+可以匹配一個或多個字符，而子表達(dá)式(\w+\.)+可匹配像xxxx.edu.這樣的字符串，而最后不會是.字符結(jié)尾，所以后面還會有一個\w+。像mhmyqn@xxxx.edu.cn這樣的郵件地址也會匹配到。

2、匹配零個或多個字符

         匹配零個或多個字符使用元符*，它的用法和+完全一樣，只要把它放在一下字符或字符集合的后面，就可以匹配該字符（或字符集合）連續(xù)出現(xiàn)零次或多次。如正則表達(dá)式ab*c可以匹配ac、abc、abbbbbc等。

3、匹配零個或一個字符

         匹配零個或一個字符使用元字符?。像上一篇說到的匹配一個空白行使用正則表達(dá)式\r\n\r\n，但在Unix和Linux中不需要\r，就可以使用元字符?，\r?\n\r?\n這樣既可匹配windows中的空白行，也可匹配Unix和Linux中的空白行。下面來看一個匹配http或https協(xié)議的URL的例子：

文本：The URL is http://www.mikan.com, to connect securely use https://www.mikan.cominstead.

正則表達(dá)式：https?://(\w+\.)+\w+

結(jié)果：The URL is 【http://www.mikan.com】, to connect securely use 【https://www.mikan.com】 instead.

分析：這個模式以https?開頭，表示?之前的一個字符可以有，也可以沒有，所以它能匹配http或https，后面部分和前一個例子一樣。

二、匹配的重復(fù)次數(shù)

         正則表達(dá)式里的+、*和?解決了很多問題，但是：

         1）+和*匹配的字符個數(shù)沒有上限。我們無法為它們將匹配的字符個數(shù)設(shè)定一個最大值。

         2）+、*和?至少匹配一個或零個字符。我們無法為它們將匹配的字符個數(shù)另行設(shè)定一個最小值。

         3）如果只使用*和+，我們無法把它們將匹配的字符個數(shù)設(shè)定為一個精確的數(shù)字。

         正則表達(dá)式里提供了一個用來設(shè)定重復(fù)次數(shù)的語法，重復(fù)次數(shù)要用{和}字符來給出，把數(shù)值寫在它們中間。

         1、為重復(fù)匹配次數(shù)設(shè)定一個精確值

         如果想為重復(fù)匹配次數(shù)設(shè)定一個精確的值，把那個數(shù)字寫在{和}之間即可。如{4}表示它前面的那個字符（或字符集合）必須在原始文本中連續(xù)重復(fù)出現(xiàn)4次才算是一個匹配，如果只出現(xiàn)了3次，也不算是一個匹配。

         如前面幾篇中說到的匹配頁面中顏色的例子，就可以用重復(fù)次數(shù)來匹配：#[[:xdigit:]]{6}或#[0-9a-fA-F]{6}，POSIX字符在java中是#\\p{XDigit}{6}。

         2、為重復(fù)匹配次數(shù)設(shè)定一個區(qū)間

         {}語法還可以用來為重復(fù)匹配次數(shù)設(shè)定一個區(qū)間，也就是為重復(fù)匹配次數(shù)設(shè)定一個最小值和最大值。這種區(qū)間必須以{n, m}這樣的形式給出，其中n>=m>=0。如檢查日期格式是否正確（不檢查日期的有效性）的正則表達(dá)式（如日期2012-08-12或2012-8-12）：\d{4}-\d{1,2}-\d{1,2}。

         3、匹配至少重復(fù)多少次

         {}語法的最后一種用法是給出一個最小的重復(fù)次數(shù)（但不必給出最大重復(fù)次數(shù)），如{3,}表示至少重復(fù)3次。注意：{3,}中一定要有逗號，而且逗號后不能有空格。否則會出錯。

         來看一個例子，使用正則表達(dá)式把所有金額大于$100的金額找出來：

文本：

$25.36

$125.36

$205.0

$2500.44

$44.30

正則表達(dá)式：$\d{3,}\.\d{2}

結(jié)果：

$25.36

【$125.36】

【$205.0】

【$2500.44】

$44.30

         +、*、?可以表示成重復(fù)次數(shù)：

         +等價于{1,}

         *等價于{0,}

         ?等價于{0,1}

三、防止過度匹配

         ?只能匹配零個或一個字符，{n}和{n,m}也有匹配重復(fù)次數(shù)的上限，但是像*、+、{n,}都沒有上限值，這樣有時會導(dǎo)致過度匹配的現(xiàn)象。

         來看匹配一個html標(biāo)簽的例子

文本：

Yesterday is <b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>.

正則表達(dá)式：<[Bb]>.*</[Bb]>

結(jié)果：

Yesterday is 【<b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>】.

分析：<[Bb]>匹配<b>標(biāo)簽（不區(qū)分大小寫），</[Bb]>匹配</b>標(biāo)簽（不區(qū)分大小寫）。但結(jié)果卻不是預(yù)期的那樣有三個，第一個</b>標(biāo)簽之后，一直到最后一個</b>之間的東西全部匹配出來了。

         為什么會這樣呢？因?yàn)?和+都是貪婪型的元字符，它們在匹配時的行為模式是多多益善，它們會盡可能從一段文本的開頭一直匹配到這段文本的末尾，而不是從這段文本的開頭匹配到碰到第一個匹配時為止。

         當(dāng)不需要這種貪婪行為時，可以使用這些元字符的懶惰型版本。懶惰意思是匹配盡可能少的字符，與貪婪型相反。懶惰型元字符只需要給貪婪型元字符加上一個?后綴即可。下面是貪婪型元字符的對應(yīng)懶惰型版本：

         *       *?

         +       +?

         {n,}   {n,}?

         所以上面的例子中，正則表達(dá)式只需要改成<[Bb]>.*?</[Bb]>即可，結(jié)果如下：

<b>history</b>

<B>mystery</B>

<b>gift</b>

四、總結(jié)

         正則表達(dá)式的真下威力體現(xiàn)在重復(fù)次數(shù)匹配方面。這里介紹了+、*、?幾種元字符的用法，如果要精確的確定匹配次數(shù)，使用{}。元字符分貪婪型和懶惰型兩種，在需要防止過度匹配的場合下，請使用懶惰型元字符來構(gòu)造正則表達(dá)式

posted @ 2012-08-15 17:37 透明的魚 閱讀(360) | 評論 (0) | 編輯 收藏

轉(zhuǎn)載：正則表達(dá)式學(xué)習(xí)--元字符的使用

轉(zhuǎn)載：http://www.tkk7.com/zhanghu198901/archive/2012/08/12/385337.html
PS：在所有例子中正則表達(dá)式匹配結(jié)果包含在源文本中的【和】之間，有的例子會使用java來實(shí)現(xiàn)，如果是java本身正則表達(dá)式的用法，會在相應(yīng)的地方說明。所有java例子都在JDK1.6.0_13下測試通過。

一、對特殊字符進(jìn)行轉(zhuǎn)義

         元字符是一些在正則表達(dá)式里有著特殊含義的字符。因?yàn)樵址谡齽t表達(dá)式里有著特殊的含義，所以這些字符就無法用來代表它們本身。在元字符前面加上一個反斜杠就可以對它進(jìn)行轉(zhuǎn)義，這樣得到的轉(zhuǎn)義序列將匹配那個字符本身而不是它特殊的元字符含義。如，如果想要匹配[和]，就必須對它進(jìn)行轉(zhuǎn)義：\[和\]。

         對元字符轉(zhuǎn)義需要用到斜杠\字符，這就意味著\字符本向也是一個元字符，要匹配\字符本身，必須轉(zhuǎn)義成\\。如匹配windows文件路徑。

二、匹配空白字符

         元字符大致可以分為兩種：一種是用來匹配文本的（如.），另一種是正則表達(dá)式的語法所要求的（如[和]）。

         在進(jìn)行正則表達(dá)式搜索的時候，我們經(jīng)常會遇到需要對原始文本中里的非打印空白字符進(jìn)行匹配的情況。比如說，我們可能需要把所有的制表符找出來，或者我們需要把換行符找出來，這類字符很難被直接輸入到一個正則表達(dá)式里，這時我們可以使用如下列出的特殊元字符來輸入它們：

         \b     回退（并刪除）一個字符（Backspace鍵）

         \f      換頁符

         \n     換行符

         \r      回車符

         \t      制表符（Tab鍵）

         \v      垂直制表符

         來看一個例子，把文件中的空白行去掉：

文本：

8 5 4 1 6 3  2 7 9

7 6 2 9 5 8  3 4 1

9 3 1 4 2 7  8 5 6

6 9 3 8 7 5  1 2 4

5 1 8 3 4 2  6 9 7

2 4 7 6 1 9  5 3 8

3 26  7 8 4 9 1 5                                                       

4 8 9 5 3 1  7 6 2

1 7 5 2 9 6  4 8 3

正則表達(dá)式：\r\n\r\n

分析：\r\n匹配一個回車+換行組合，windows操作系統(tǒng)中把它作為文本行的結(jié)束標(biāo)簽。使用正則表達(dá)式\r\n\r\n進(jìn)行的搜索將匹配兩個連續(xù)的行尾標(biāo)簽，而這正好是空白行。

         注意：Unix和Linux操作系統(tǒng)中只使用一個換行符來結(jié)束一個文本行，換句話說，在Unix或Linux系統(tǒng)中匹配空白行只使用\n\n即可，不需要加上\r。同時適用于windows和Unix/Linux的正則表達(dá)式應(yīng)該包括一個可先的\r和一個必須匹配的\n，即\r?\n\r?\n，這將會在后面的文章中講到。

         Java代碼如下：

原內(nèi)容：

8 5 4  1 6 3 2 7 9

7 6 2  9 5 8 3 4 1

9 3 1  4 2 7 8 5 6

6 9 3  8 7 5 1 2 4

5 1 8  3 4 2 6 9 7

2 4 7  6 1 9 5 3 8

3 2 6  7 8 4 9 1 5

4 8 9  5 3 1 7 6 2

1 7 5  2 9 6 4 8 3

處理后：-----------------------------

8 5 4  1 6 3 2 7 9

7 6 2  9 5 8 3 4 1

9 3 1  4 2 7 8 5 6

6 9 3  8 7 5 1 2 4

5 1 8  3 4 2 6 9 7

2 4 7  6 1 9 5 3 8

3 2 6  7 8 4 9 1 5

4 8 9  5 3 1 7 6 2

1 7 5  2 9 6 4 8 3

三、匹配特定的字符類別

         字符集合（匹配多個字符中的某一個）是最常見的匹配形式，而一些常用的字符集合可以用特殊元字符來代替。這些元字符匹配的是某一類別的字符（類元字符），類元字符并不是必不可少的，因?yàn)榭梢酝ㄟ^逐一列舉有關(guān)字符或通過定義一個字符區(qū)間來匹配某一類字符，但是使用它們構(gòu)造出來的正則表達(dá)式簡明易懂，在實(shí)際應(yīng)用中很常用。

         1、匹配數(shù)字與非數(shù)字

         \d     任何一個數(shù)字，等價于[0-9]或[0123456789]

         \D     任何一個非數(shù)字，等價于[^0-9]或[^0123456789]

         2、匹配字母和數(shù)字與非字母和數(shù)字

         字母（A-Z不區(qū)分大小寫）、數(shù)字、下劃線是一種常用的字符集合，可用如下類元字符：

         \w    任何一個字母（不區(qū)分大小寫）、數(shù)字、下劃線，等價于[0-9a-zA-Z_]

         \W    任何一個非字母數(shù)字和下劃線，等價于[^0-9a-zA-Z_]

         3、匹配空白字符與非空白字符

         \s      任何一下空白字符，等價于[\f\n\r\t\v]

         \S      任何一下空白字符，等價于[^\f\n\r\t\v]

         注意：退格元字符\b沒有不在\s的范圍之內(nèi)。

         4、匹配十六進(jìn)制或八進(jìn)制數(shù)值

         十六進(jìn)制：用前綴\x來給出，如：\x0A對應(yīng)于ASCII字符10（換行符），其效果等價于\n。

         八進(jìn)制：用前綴\0來給出，數(shù)值本身可以是兩位或三位數(shù)字，如：\011對應(yīng)于ASCII字符9（制表符），其效果等價于\t。

四、使用POSIX字符類

         POSIX字符類是很多正則表達(dá)式實(shí)現(xiàn)都支持的一種簡寫形式。Java也支持它，但JavaScript不支持。POSIX字符如下所示：

[:alnum:]  任何一個字母或數(shù)字，等價于[a-zA-Z0-9]

[:alpha:]   任何一個字母，等價于[a-zA-Z]

[:blank:]   空格或制表符，等價于[\t]

[:cntrl:]     ASCII控制字符（ASCII 0到31，再加上ASCII 127）

[:digit:]     任何一個數(shù)字，等價于[0-9]

[:graph:]  任何一個可打印字符，但不包括空格

[:lower:]   任何一個小寫字母，等價于[a-z]

[:print:]    任何一個可打印字符

[:punct:]   既不屬于[:alnum:]和[:cntrl:]的任何一個字符

[:space:]  任何一個空白字符，包括空格，等價于[^\f\n\r\t\v]

[:upper:]  任何一個大寫字母，等價于[A-Z]

[:xdigit:]   任何一個十六進(jìn)制數(shù)字，等價于[a-fA-F0-9]

         POSIX字符和之前見過的元字符不太一樣，我們來看一個前面利用正則表達(dá)式來匹配網(wǎng)頁中的顏色的例子：

文本：<span style="background-color:#3636FF;height:30px;width:60px;">測試</span>

正則表達(dá)式：#[[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]]

結(jié)果：<span style="background-color:【#3636FF】;height:30px;width:60px;">測試</span>

注意：這里使用的模式以[[開頭、以]]結(jié)束，這是使用POSIX字符類所必須的，POSIX字符必須括在[:和:]之間，外層[和]字符用來定義一個集合，內(nèi)層的[和]字符是POSIX字符類本身的組成部分。

在java中的POSIX字符表示有所不同，不是包括在[:和:]之間，而是以\p開頭，包括在{和}之間，且大小寫有區(qū)別，同時增加了\p{ASCII}，如下所示：

\p{Alnum}         字母數(shù)字字符：[\p{Alpha}\p{Digit}]

\p{Alpha}          字母字符：[\p{Lower}\p{Upper}]

\p{ASCII}           所有 ASCII：[\x00-\x7F]

\p{Blank}           空格或制表符：[ \t]

\p{Cntrl}            控制字符：[\x00-\x1F\x7F]

\p{Digit}            十進(jìn)制數(shù)字：[0-9]

\p{Graph}          可見字符：[\p{Alnum}\p{Punct}]

\p{Lower}          小寫字母字符：[a-z]

\p{Print}            可打印字符：[\p{Graph}\x20]

\p{Punct}          標(biāo)點(diǎn)符號：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

\p{Space}          空白字符：[ \t\n\x0B\f\r]

\p{Upper}          大寫字母字符：[A-Z]

\p{XDigit}          十六進(jìn)制數(shù)字：[0-9a-fA-F]

posted @ 2012-08-15 17:35 透明的魚 閱讀(227) | 評論 (0) | 編輯 收藏

Java關(guān)鍵字final、static使用總結(jié)

一、final
　根據(jù)程序上下文環(huán)境，Java關(guān)鍵字final有“這是無法改變的”或者“終態(tài)的”含義，它可以修飾非抽象類、非抽象類成員方法和變量。你可能出于兩種理解而需要阻止改變：設(shè)計或效率。
final類不能被繼承，沒有子類，final類中的方法默認(rèn)是final的。
final方法不能被子類的方法覆蓋，但可以被繼承。
final成員變量表示常量，只能被賦值一次，賦值后值不再改變。
final不能用于修飾構(gòu)造方法。
注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認(rèn)是final類型的。

1、final類
　final類不能被繼承，因此final類的成員方法沒有機(jī)會被覆蓋，默認(rèn)都是final的。在設(shè)計類時候，如果這個類不需要有子類，類的實(shí)現(xiàn)細(xì)節(jié)不允許改變，并且確信這個類不會載被擴(kuò)展，那么就設(shè)計為final類。

2、final方法
如果一個類不允許其子類覆蓋某個方法，則可以把這個方法聲明為final方法。
使用final方法的原因有二：
第一、把方法鎖定，防止任何繼承類修改它的意義和實(shí)現(xiàn)。
第二、高效。編譯器在遇到調(diào)用final方法時候會轉(zhuǎn)入內(nèi)嵌機(jī)制，大大提高執(zhí)行效率。
例如：

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(); //調(diào)用從父類繼承過來的final方法 t.f3(); //調(diào)用從父類繼承過來的方法 //t.f4(); //調(diào)用失敗，無法從父類繼承獲得 } }

3、final變量（常量）
　用final修飾的成員變量表示常量，值一旦給定就無法改變！
　final修飾的變量有三種：靜態(tài)變量、實(shí)例變量和局部變量，分別表示三種類型的常量。
　從下面的例子中可以看出，一旦給final變量初值后，值就不能再改變了。
　另外，final變量定義的時候，可以先聲明，而不給初值，這中變量也稱為final空白，無論什么情況，編譯器都確保空白final在使用之前必須被初始化。但是，final空白在final關(guān)鍵字final的使用上提供了更大的靈活性，為此，一個類中的final數(shù)據(jù)成員就可以實(shí)現(xiàn)依對象而有所不同，卻有保持其恒定不變的特征。

package org.leizhimin; public class Test3 { private final String S="final實(shí)例變量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); //不推薦用對象方式訪問靜態(tài)字段 System.out.println(t.D); //不推薦用對象方式訪問靜態(tài)字段 System.out.println(Test3.C); System.out.println(Test3.D); //System.out.println(Test3.E); //出錯,因?yàn)镋為final空白,依據(jù)不同對象值有所不同. System.out.println(t.E); Test3 t1=new Test3(3); System.out.println(t1.E); //final空白變量E依據(jù)對象的不同而不同 } 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; 出錯,已經(jīng)給賦過值了. //b=2; 出錯,已經(jīng)給賦過值了. } }

 
4、final參數(shù)
當(dāng)函數(shù)參數(shù)為final類型時，你可以讀取使用該參數(shù)，但是無法改變該參數(shù)的值。

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); } }

二、static

　static表示“全局”或者“靜態(tài)”的意思，用來修飾成員變量和成員方法，也可以形成靜態(tài)static代碼塊，但是Java語言中沒有全局變量的概念。

　被static修飾的成員變量和成員方法獨(dú)立于該類的任何對象。也就是說，它不依賴類特定的實(shí)例，被類的所有實(shí)例共享。只要這個類被加載，Java虛擬機(jī)就能根據(jù)類名在運(yùn)行時數(shù)據(jù)區(qū)的方法區(qū)內(nèi)定找到他們。因此，static對象可以在它的任何對象創(chuàng)建之前訪問，無需引用任何對象。

　用public修飾的static成員變量和成員方法本質(zhì)是全局變量和全局方法，當(dāng)聲明它類的對象市，不生成static變量的副本，而是類的所有實(shí)例共享同一個static變量。

　static變量前可以有private修飾，表示這個變量可以在類的靜態(tài)代碼塊中，或者類的其他靜態(tài)成員方法中使用（當(dāng)然也可以在非靜態(tài)成員方法中使用--廢話），但是不能在其他類中通過類名來直接引用，這一點(diǎn)很重要。實(shí)際上你需要搞明白，private是訪問權(quán)限限定，static表示不要實(shí)例化就可以使用，這樣就容易理解多了。static前面加上其它訪問權(quán)限關(guān)鍵字的效果也以此類推。

　static修飾的成員變量和成員方法習(xí)慣上稱為靜態(tài)變量和靜態(tài)方法，可以直接通過類名來訪問，訪問語法為：
類名.靜態(tài)方法名(參數(shù)列表...)
類名.靜態(tài)變量名

　用static修飾的代碼塊表示靜態(tài)代碼塊，當(dāng)Java虛擬機(jī)（JVM）加載類時，就會執(zhí)行該代碼塊（用處非常大，呵呵）。

1、static變量
　按照是否靜態(tài)的對類成員變量進(jìn)行分類可分兩種：一種是被static修飾的變量，叫靜態(tài)變量或類變量；另一種是沒有被static修飾的變量，叫實(shí)例變量。兩者的區(qū)別是：
　對于靜態(tài)變量在內(nèi)存中只有一個拷貝（節(jié)省內(nèi)存），JVM只為靜態(tài)分配一次內(nèi)存，在加載類的過程中完成靜態(tài)變量的內(nèi)存分配，可用類名直接訪問（方便），當(dāng)然也可以通過對象來訪問（但是這是不推薦的）。
　對于實(shí)例變量，沒創(chuàng)建一個實(shí)例，就會為實(shí)例變量分配一次內(nèi)存，實(shí)例變量可以在內(nèi)存中有多個拷貝，互不影響（靈活）。

2、靜態(tài)方法
　靜態(tài)方法可以直接通過類名調(diào)用，任何的實(shí)例也都可以調(diào)用，因此靜態(tài)方法中不能用this和super關(guān)鍵字，不能直接訪問所屬類的實(shí)例變量和實(shí)例方法(就是不帶static的成員變量和成員成員方法)，只能訪問所屬類的靜態(tài)成員變量和成員方法。因?yàn)閷?shí)例成員與特定的對象關(guān)聯(lián)！這個需要去理解，想明白其中的道理，不是記憶！！！
　因?yàn)閟tatic方法獨(dú)立于任何實(shí)例，因此static方法必須被實(shí)現(xiàn)，而不能是抽象的abstract。

3、static代碼塊
　static代碼塊也叫靜態(tài)代碼塊，是在類中獨(dú)立于類成員的static語句塊，可以有多個，位置可以隨便放，它不在任何的方法體內(nèi)，JVM加載類時會執(zhí)行這些靜態(tài)的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現(xiàn)的先后順序依次執(zhí)行它們，每個代碼塊只會被執(zhí)行一次。例如：

public class Test5 { private static int a; private int b; static{ Test5.a=3; System.out.println(a); Test5 t=new Test5(); t.f(); t.b=1000; System.out.println(t.b); } static{ Test5.a=4; System.out.println(a); } public static void main(String[] args) { // TODO 自動生成方法存根 } static{ Test5.a=5; System.out.println(a); } public void f(){ System.out.println("hhahhahah"); } }

 

運(yùn)行結(jié)果：
3
hhahhahah
1000
4
5

　利用靜態(tài)代碼塊可以對一些static變量進(jìn)行賦值，最后再看一眼這些例子，都一個static的main方法，這樣JVM在運(yùn)行main方法的時候可以直接調(diào)用而不用創(chuàng)建實(shí)例。

4、static和final一塊用表示什么
static final用來修飾成員變量和成員方法，可簡單理解為“全局常量”！
對于變量，表示一旦給值就不可修改，并且通過類名可以訪問。
對于方法，表示不可覆蓋，并且可以通過類名直接訪問。

posted @ 2012-06-14 13:53 透明的魚 閱讀(254) | 評論 (0) | 編輯 收藏

ThreadLocal類（2）

什么是ThreadLocal？

顧名思義它是local variable（線程局部變量）。它的功用非常簡單，就是為每一個使用該變量的線程都提供一個變量值的副本，是每一個線程都可以獨(dú)立地改變自己的副本，而不會和其它線程的副本沖突。從線程的角度看，就好像每一個線程都完全擁有該變量。

使用場景

1. To keep state with a thread (user-id, transaction-id, logging-id)
2. To cache objects which you need frequently

ThreadLocal類

它主要由四個方法組成initialValue()，get()，set(T)，remove()，其中值得注意的是initialValue()，該方法是一個protected的方法，顯然是為了子類重寫而特意實(shí)現(xiàn)的。該方法返回當(dāng)前線程在該線程局部變量的初始值，這個方法是一個延遲調(diào)用方法，在一個線程第1次調(diào)用get()或者set(Object)時才執(zhí)行，并且僅執(zhí)行1次。ThreadLocal中的確實(shí)實(shí)現(xiàn)直接返回一個null：

ThreadLocal的原理

ThreadLocal是如何做到為每一個線程維護(hù)變量的副本的呢？其實(shí)實(shí)現(xiàn)的思路很簡單，在ThreadLocal類中有一個Map，用于存儲每一個線程的變量的副本。比如下面的示例實(shí)現(xiàn)：

public class ThreadLocal
{
　private Map values = Collections.synchronizedMap(new HashMap());
　public Object get()
　{
　　Thread curThread = Thread.currentThread();
　　Object o = values.get(curThread);
　　if (o == null && !values.containsKey(curThread))
　　{
　　　o = initialValue();
　　　values.put(curThread, o);
　　}
　　return o;
　}

　public void set(Object newValue)
　{
　　values.put(Thread.currentThread(), newValue);
　}

　public Object initialValue()
　{
　　return null;
　}
}

ThreadLocal 的使用

使用方法一：

Hibernate的文檔時看到了關(guān)于使ThreadLocal管理多線程訪問的部分。具體代碼如下

1.  public static final ThreadLocal session = new ThreadLocal();
2.  public static Session currentSession() {
3.      Session s = (Session)session.get();
4.      //open a new session,if this session has none
5.   if(s == null){
6.      s = sessionFactory.openSession();
7.      session.set(s);
8.   }
      return s;
9. }

我們逐行分析
1。 初始化一個ThreadLocal對象，ThreadLocal有三個成員方法 get()、set()、initialvalue()。
    如果不初始化initialvalue，則initialvalue返回null。
3。session的get根據(jù)當(dāng)前線程返回其對應(yīng)的線程內(nèi)部變量，也就是我們需要的net.sf.hibernate.Session（相當(dāng)于對應(yīng)每個數(shù)據(jù)庫連接）.多線程情況下共享數(shù)據(jù)庫鏈接是不安全的。ThreadLocal保證了每個線程都有自己的s（數(shù)據(jù)庫連接）。
5。如果是該線程初次訪問，自然，s（數(shù)據(jù)庫連接）會是null，接著創(chuàng)建一個Session，具體就是行6。
6。創(chuàng)建一個數(shù)據(jù)庫連接實(shí)例 s
7。保存該數(shù)據(jù)庫連接s到ThreadLocal中。
8。如果當(dāng)前線程已經(jīng)訪問過數(shù)據(jù)庫了，則從session中g(shù)et()就可以獲取該線程上次獲取過的連接實(shí)例。

使用方法二

當(dāng)要給線程初始化一個特殊值時，需要自己實(shí)現(xiàn)ThreadLocal的子類并重寫該方法，通常使用一個內(nèi)部匿名類對ThreadLocal進(jìn)行子類化，EasyDBO中創(chuàng)建jdbc連接上下文就是這樣做的：

public class JDBCContext{
 private static Logger logger = Logger.getLogger(JDBCContext.class);
 private DataSource ds;
 protected Connection connection;
 private boolean isValid = true;
 private static ThreadLocal jdbcContext;
 
 private JDBCContext(DataSource ds){
  this.ds = ds;
  createConnection();  
 }
 public static JDBCContext getJdbcContext(javax.sql.DataSource ds)
 {  
  if(jdbcContext==null)jdbcContext=new JDBCContextThreadLocal(ds);
  JDBCContext context = (JDBCContext) jdbcContext.get();
  if (context == null) {
   context = new JDBCContext(ds);
  }
  return context;
 }

 private static class JDBCContextThreadLocal extends ThreadLocal {
  public javax.sql.DataSource ds;
  public JDBCContextThreadLocal(javax.sql.DataSource ds)
  {
   this.ds=ds;
  }
  protected synchronized Object initialValue() {
   return new JDBCContext(ds);
  }
 }
}

使用單例模式，不同的線程調(diào)用getJdbcContext()獲得自己的jdbcContext，都是通過JDBCContextThreadLocal 內(nèi)置子類來獲得JDBCContext對象的線程局部變量，這個變

posted @ 2012-05-31 13:16 透明的魚 閱讀(288) | 評論 (0) | 編輯 收藏

ThreadLocal類（1）

1.目的

ThreadLocal目的是保存一些線程級別的全局變量，比如connection，或者事務(wù)上下文，避免這些值需要一直通過函數(shù)參數(shù)的方式一路傳遞。

2. 常見用法
舉例其中一種常見用法：

public class Test2 {
	public static void main(String[] args) throws InterruptedException {
		testThreadLocal();
	}
 
	private static void testThreadLocal() {
		Util.setGlobalName("zili.dengzl");
		new Foo().printName();
	}
}
 
class Foo{
	public void printName(){
		System.out.println("globalName="+Util.getGlobalName());
	}
}
 
class Util {
	private static final ThreadLocal<String> globalName = new ThreadLocal<String>();
 
	public static String getGlobalName() {
		return globalName.get();
	}
 
	public static void setGlobalName(String name) {
		globalName.set(name);
	}
}

3.實(shí)現(xiàn)分析

要實(shí)現(xiàn)上面這樣的功能，最簡單的想法是用一個Map<Thread,T>,如下：

class MockThreadLocal<T> {
	private Map<Thread, T> map = new HashMap<Thread, T>();
 
	public T get() {
		return (T) map.get(Thread.currentThread());
	}
 
	public void set(T value) {
		map.put(Thread.currentThread(), value);
	}
}

這樣也能實(shí)現(xiàn)ThreadLocal的效果，但是有一個問題，當(dāng)對應(yīng)的線程消失后，map中對應(yīng)的線程值并不會被回收，從而造成內(nèi)存泄露。

事實(shí)上ThreadLocal是這樣做的：

每個Thread都有一個threadLocalMap，key是threadLocal對象，value是具體使用的值。ThreadLocal對象的get就是先取得當(dāng)前的Thread，然后從這個Thread的threadLcoalMap中取出值。set類似。

下面看下具體代碼：

    /**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }

注意這里如果取到?jīng)]有該線程對應(yīng)的值，會調(diào)用setInitialValue();，最終調(diào)用initialValue()生成一個值，這也是我們很多場景下要override這個方法的原因；

下面看一下getMap(Thread t)方法：

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

在Thread類中：

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

由此可見，所有的ThreadLocal的信息，最終是關(guān)聯(lián)到Thread上的，線程消失后，對應(yīng)的Thread對象也被回收，這時對應(yīng)的ThreadLocal對象(該線程部分)也會被回收。

這里為什么是一個ThreadLocalMap呢，因?yàn)橐粋€線程可以有多個ThreadLocal變量，通過map.getEntry(this)取得對應(yīng)的某個具體的變量。

        private Entry getEntry(ThreadLocal key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

最后要注意的一點(diǎn)是，ThreadLocalMap的Entry是一個weakReference：

       /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;
 
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

這里主要因?yàn)門hreadLocalMap的key是ThreadLocal對象，如果某個ThreadLocal對象所有的強(qiáng)引用沒有了，會利用weakref的功能把他回收掉，然后復(fù)用這個entry。

考慮一下如果不用weakReference會出現(xiàn)什么情況：假設(shè)某個對象是這樣引用的

private final ThreadLocal<String> globalName = new ThreadLocal<String>();

注意沒有static，然后這個對象被不斷的new出來，然后死掉，每次ThreadLocalmap中都會多出一個entry，然后這個entry強(qiáng)引用一個ThreadLocal對象，ThreadLocalMap本身就沒有辦法確定哪個entry是不用了的，如果恰好這個線程是線程池中的，會存活很久，那就杯具了。

ThreadLocalMap用了weakReference，失去強(qiáng)引用的ThreadLocal對象會在下次gc時被回收，然后ThreadLocalMap本身在get和set的時候會考察key為空的Entry，并復(fù)用它或者清除，從而避免內(nèi)存泄露。

這樣看來，HashMap也有一樣的問題，但為什么hashMap不這樣呢，因?yàn)閔ashMap的put是業(yè)務(wù)代碼操作的，因此如果有長期存活的HashMap，（比如static的）業(yè)務(wù)代碼put進(jìn)去就有義務(wù)去remove，但ThreadLocal的put操作時ThreadLocal類干的，業(yè)務(wù)代碼不知道，因此也不會去做remove，而ThreadLocalMap本身不知道引用他的某個entry的key的對象什么時候死掉了，那么如果不用弱引用，就不知道這個ThreadLocal對象什么時候需要回收了。

附：

這里補(bǔ)充一下weakReference的用法供參考（當(dāng)強(qiáng)引用不存在時，下次垃圾回收會回收弱引用所引用的對象）：

		Object o = new Object();
		WeakReference<Object> ref = new WeakReference<Object>(o);
		System.out.println(ref.get());
		o=null;
		System.gc();
		System.out.println(ref.get());

結(jié)果輸出：

 java.lang.Object@de6ced
 null

4. FAQ

4.1 為什么一般的ThreadLocal用法都要加static，如下：

class Test {
    private static final ThreadLocal<String> globalName = new ThreadLocal<String>();
}

class TestThreadLocal{    
    public static void main(String[] args) {
		Test t1 = new Test();
		Test t2 = new Test();
 
		t1.pool.set("a");
		System.out.println(t1.pool.get());
		System.out.println(t2.pool.get());
	}
}
class Test{
	public ThreadLocal pool = new ThreadLocal();
}

輸出將會是：a，null

原因就無需多解釋了。唯一需要啰嗦的一點(diǎn)是，就算一般情況都是單例，上面那個weakreference還是必要的，因?yàn)樽鳛榭蚣艽a，不能保證正常使用的情況下一個線程有很多ThreadLocal，如果不用weakreference，就會有內(nèi)存泄漏的風(fēng)險，特別是針對線程池中的線程。

posted @ 2012-05-31 13:15 透明的魚 閱讀(591) | 評論 (0) | 編輯 收藏

對Spring事務(wù)配置的五種方式（轉(zhuǎn)載）

posted @ 2012-05-30 14:33 透明的魚 閱讀(242) | 評論 (0) | 編輯 收藏

jdbc連接數(shù)據(jù)庫步驟（轉(zhuǎn)載）

posted @ 2012-05-15 09:20 透明的魚 閱讀(230) | 評論 (0) | 編輯 收藏

java集合詳解

本文系 www.javady.com網(wǎng)站原創(chuàng)
總接口：Iterable<T>  實(shí)現(xiàn)這個接口允許對象成為 "foreach" 語句的目標(biāo)。

   Collection<E> 層次結(jié)構(gòu) 中的根接口。Collection 表示一組對象

一、   List  ：實(shí)現(xiàn) collection接口  有序的集合  可以允許重復(fù)

二、Set   ：一個不包含重復(fù)元素的 collection。

三、Map  ：一個不包含重復(fù)元素的 無序集合  鍵值對 。

Map m = Collections.synchronizedMap(new LinkedHashMap(...))

Map m = Collections.synchronizedMap(new TreeMap(...));

posted @ 2012-05-14 16:50 透明的魚 閱讀(294) | 評論 (0) | 編輯 收藏

xstream 讓javabean和xml互相轉(zhuǎn)換(轉(zhuǎn)載)

posted @ 2012-05-14 16:01 透明的魚 閱讀(3950) | 評論 (0) | 編輯 收藏

java知識

posted @ 2012-04-18 16:23 透明的魚 閱讀(14) | 評論 (0) | 編輯 收藏

調(diào)用百度地圖小實(shí)例

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "<html xmlns="<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<meta name="keywords" content="" />
<meta name="description" content="百度地圖API自定義地圖，幫助用戶在可視化操作下生成百度地圖" />
<title>百度地圖API自定義地圖</title>
<!--引用百度地圖API-->
<style type="text/css">
    html,body{margin:0;padding:0;}
    .iw_poi_title {color:#CC5522;font-size:14px;font-weight:bold;overflow:hidden;padding-right:13px;white-space:nowrap}
    .iw_poi_content {font:12px arial,sans-serif;overflow:visible;padding-top:4px;white-space:-moz-pre-wrap;word-wrap:break-word}
</style>
<script type="text/javascript" src=">
</head>

        var point = new BMap.Point(121.323246, 31.294085);
        var marker = new BMap.Marker(point);
        var label = new BMap.Label('上海分公司',{"offset":new BMap.Size(9,-15)});
        marker.setLabel(label);
        map.addOverlay(marker);
        marker.addEventListener("click", function(){this.openInfoWindow(new BMap.InfoWindow("上海分公司</br>Tel:暫無", opts));});
    }
    // 編寫自定義函數(shù),創(chuàng)建標(biāo)注
    function addMarker(point, index) {
        var myIcon = new BMap.Icon("            offset: new BMap.Size(10, 25),                  // 指定定位位置
            imageOffset: new BMap.Size(0, 0 - index * 25)   // 設(shè)置圖片偏移
        });
        var marker = new BMap.Marker(point, { icon: myIcon });
        map.addOverlay(marker);
    }

posted @ 2012-04-18 16:19 透明的魚 閱讀(10093) | 評論 (2) | 編輯 收藏