#
摘要: 轉(zhuǎn)載：http://www.tkk7.com/qcyycom/archive/2013/07/11/401467.htmlSpring MVC 3 深入總結(jié)
一、前言：
大家好，Spring3 MVC是非常優(yōu)秀的MVC框架，由其是在3.0版本發(fā)布后，現(xiàn)在有越來越多的團(tuán)隊(duì)選擇了Spring3 MVC了。Spring3 MVC結(jié)構(gòu)簡單，應(yīng)了那句話簡單就是美，而且他強(qiáng)大不失靈活，性能...
閱讀全文
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)
使用POI對excel表數(shù)據(jù)進(jìn)行操作時(shí)出現(xiàn)了該問題，從數(shù)據(jù)庫導(dǎo)出數(shù)據(jù)到excel表中，datetime類型的數(shù)據(jù)以String類型存儲，當(dāng)對表內(nèi)的該列數(shù)據(jù)做修改后，excel將自動(dòng)修改單元格的格式，從而導(dǎo)致在重新讀取時(shí)出現(xiàn)了以上錯(cuò)誤。
解決辦法：
判斷讀取的單元格是否為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;
轉(zhuǎn)載：
http://www.tkk7.com/zhanghu198901/archive/2012/08/12/385337.html
PS：在所有例子中正則表達(dá)式匹配結(jié)果包含在源文本中的【和】之間，有的例子會(huì)使用java來實(shí)現(xiàn)，如果是java本身正則表達(dá)式的用法，會(huì)在相應(yīng)的地方說明。所有java例子都在JDK1.6.0_13下測試通過。
一、有多少個(gè)匹配
前面幾篇講的都是匹配一個(gè)字符，但是一個(gè)字符或字符集合要匹配多次，應(yīng)該怎么做呢？比如要匹配一個(gè)電子郵件地址，用之前說到的方法，可能有人會(huì)寫出像\w@\w\.\w這樣的正則表達(dá)式，但這個(gè)只能匹配到像a@b.c這樣的地址，明顯是不正確的，接下來就來看看如何匹配電子郵件地址。
首先要知道電子郵件地址的組成：以字母數(shù)字或下劃線開頭的一組字符，后面跟@符號，再后面是域名，即用戶名@域名地址。不過這也跟具體的郵箱服務(wù)提供商有關(guān)，有的在用戶名中也允許.字符。
1、匹配一個(gè)或多個(gè)字符
要想匹配同一個(gè)字符（或字符集合）的多次重復(fù)，只要簡單地給這個(gè)字符（或字符集合）加上一個(gè)+字符作為后綴就可以了。+匹配一個(gè)或多個(gè)字符（至少一個(gè)）。如：a匹配a本身，a+將匹配一個(gè)或多個(gè)連續(xù)出現(xiàn)的a；[0-9]+匹配多個(gè)連續(xù)的數(shù)字。
注意：在給一個(gè)字符集合加上+后綴的時(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+可以匹配一個(gè)或多個(gè)字符，而子表達(dá)式(\w+\.)+可匹配像xxxx.edu.這樣的字符串，而最后不會(huì)是.字符結(jié)尾，所以后面還會(huì)有一個(gè)\w+。像mhmyqn@xxxx.edu.cn這樣的郵件地址也會(huì)匹配到。
2、匹配零個(gè)或多個(gè)字符
匹配零個(gè)或多個(gè)字符使用元符*，它的用法和+完全一樣，只要把它放在一下字符或字符集合的后面，就可以匹配該字符（或字符集合）連續(xù)出現(xiàn)零次或多次。如正則表達(dá)式ab*c可以匹配ac、abc、abbbbbc等。
3、匹配零個(gè)或一個(gè)字符
匹配零個(gè)或一個(gè)字符使用元字符?。像上一篇說到的匹配一個(gè)空白行使用正則表達(dá)式\r\n\r\n，但在Unix和Linux中不需要\r，就可以使用元字符?，\r?\n\r?\n這樣既可匹配windows中的空白行，也可匹配Unix和Linux中的空白行。下面來看一個(gè)匹配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.
分析：這個(gè)模式以https?開頭，表示?之前的一個(gè)字符可以有，也可以沒有，所以它能匹配http或https，后面部分和前一個(gè)例子一樣。
二、匹配的重復(fù)次數(shù)
正則表達(dá)式里的+、*和?解決了很多問題，但是：
1）+和*匹配的字符個(gè)數(shù)沒有上限。我們無法為它們將匹配的字符個(gè)數(shù)設(shè)定一個(gè)最大值。
2）+、*和?至少匹配一個(gè)或零個(gè)字符。我們無法為它們將匹配的字符個(gè)數(shù)另行設(shè)定一個(gè)最小值。
3）如果只使用*和+，我們無法把它們將匹配的字符個(gè)數(shù)設(shè)定為一個(gè)精確的數(shù)字。
正則表達(dá)式里提供了一個(gè)用來設(shè)定重復(fù)次數(shù)的語法，重復(fù)次數(shù)要用{和}字符來給出，把數(shù)值寫在它們中間。
1、為重復(fù)匹配次數(shù)設(shè)定一個(gè)精確值
如果想為重復(fù)匹配次數(shù)設(shè)定一個(gè)精確的值，把那個(gè)數(shù)字寫在{和}之間即可。如{4}表示它前面的那個(gè)字符（或字符集合）必須在原始文本中連續(xù)重復(fù)出現(xiàn)4次才算是一個(gè)匹配，如果只出現(xiàn)了3次，也不算是一個(gè)匹配。
如前面幾篇中說到的匹配頁面中顏色的例子，就可以用重復(fù)次數(shù)來匹配：#[[:xdigit:]]{6}或#[0-9a-fA-F]{6}，POSIX字符在java中是#\\p{XDigit}{6}。
2、為重復(fù)匹配次數(shù)設(shè)定一個(gè)區(qū)間
{}語法還可以用來為重復(fù)匹配次數(shù)設(shè)定一個(gè)區(qū)間，也就是為重復(fù)匹配次數(shù)設(shè)定一個(gè)最小值和最大值。這種區(qū)間必須以{n, m}這樣的形式給出，其中n>=m>=0。如檢查日期格式是否正確（不檢查日期的有效性）的正則表達(dá)式（如日期2012-08-12或2012-8-12）：\d{4}-\d{1,2}-\d{1,2}。
3、匹配至少重復(fù)多少次
{}語法的最后一種用法是給出一個(gè)最小的重復(fù)次數(shù)（但不必給出最大重復(fù)次數(shù)），如{3,}表示至少重復(fù)3次。注意：{3,}中一定要有逗號，而且逗號后不能有空格。否則會(huì)出錯(cuò)。
來看一個(gè)例子，使用正則表達(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ù)：
+等價(jià)于{1,}
*等價(jià)于{0,}
?等價(jià)于{0,1}
三、防止過度匹配
?只能匹配零個(gè)或一個(gè)字符，{n}和{n,m}也有匹配重復(fù)次數(shù)的上限，但是像*、+、{n,}都沒有上限值，這樣有時(shí)會(huì)導(dǎo)致過度匹配的現(xiàn)象。
來看匹配一個(gè)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ù)期的那樣有三個(gè)，第一個(gè)</b>標(biāo)簽之后，一直到最后一個(gè)</b>之間的東西全部匹配出來了。
為什么會(huì)這樣呢？因?yàn)?和+都是貪婪型的元字符，它們在匹配時(shí)的行為模式是多多益善，它們會(huì)盡可能從一段文本的開頭一直匹配到這段文本的末尾，而不是從這段文本的開頭匹配到碰到第一個(gè)匹配時(shí)為止。
當(dāng)不需要這種貪婪行為時(shí)，可以使用這些元字符的懶惰型版本。懶惰意思是匹配盡可能少的字符，與貪婪型相反。懶惰型元字符只需要給貪婪型元字符加上一個(gè)?后綴即可。下面是貪婪型元字符的對應(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á)式
轉(zhuǎn)載：http://www.tkk7.com/zhanghu198901/archive/2012/08/12/385337.html
PS：在所有例子中正則表達(dá)式匹配結(jié)果包含在源文本中的【和】之間，有的例子會(huì)使用java來實(shí)現(xiàn)，如果是java本身正則表達(dá)式的用法，會(huì)在相應(yīng)的地方說明。所有java例子都在JDK1.6.0_13下測試通過。
一、對特殊字符進(jìn)行轉(zhuǎn)義
元字符是一些在正則表達(dá)式里有著特殊含義的字符。因?yàn)樵址谡齽t表達(dá)式里有著特殊的含義，所以這些字符就無法用來代表它們本身。在元字符前面加上一個(gè)反斜杠就可以對它進(jìn)行轉(zhuǎn)義，這樣得到的轉(zhuǎn)義序列將匹配那個(gè)字符本身而不是它特殊的元字符含義。如，如果想要匹配[和]，就必須對它進(jìn)行轉(zhuǎn)義：\[和\]。
對元字符轉(zhuǎn)義需要用到斜杠\字符，這就意味著\字符本向也是一個(gè)元字符，要匹配\字符本身，必須轉(zhuǎn)義成\\。如匹配windows文件路徑。
二、匹配空白字符
元字符大致可以分為兩種：一種是用來匹配文本的（如.），另一種是正則表達(dá)式的語法所要求的（如[和]）。
在進(jìn)行正則表達(dá)式搜索的時(shí)候，我們經(jīng)常會(huì)遇到需要對原始文本中里的非打印空白字符進(jìn)行匹配的情況。比如說，我們可能需要把所有的制表符找出來，或者我們需要把換行符找出來，這類字符很難被直接輸入到一個(gè)正則表達(dá)式里，這時(shí)我們可以使用如下列出的特殊元字符來輸入它們：
\b 回退（并刪除）一個(gè)字符（Backspace鍵）
\f 換頁符
\n 換行符
\r 回車符
\t 制表符（Tab鍵）
\v 垂直制表符
來看一個(gè)例子，把文件中的空白行去掉：
文本：
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匹配一個(gè)回車+換行組合，windows操作系統(tǒng)中把它作為文本行的結(jié)束標(biāo)簽。使用正則表達(dá)式\r\n\r\n進(jìn)行的搜索將匹配兩個(gè)連續(xù)的行尾標(biāo)簽，而這正好是空白行。
注意：Unix和Linux操作系統(tǒng)中只使用一個(gè)換行符來結(jié)束一個(gè)文本行，換句話說，在Unix或Linux系統(tǒng)中匹配空白行只使用\n\n即可，不需要加上\r。同時(shí)適用于windows和Unix/Linux的正則表達(dá)式應(yīng)該包括一個(gè)可先的\r和一個(gè)必須匹配的\n，即\r?\n\r?\n，這將會(huì)在后面的文章中講到。
Java代碼如下：
public static void matchBlankLine() throws Exception{
BufferedReader br = new BufferedReader(new FileReader(new File("E:/九宮格.txt")));
StringBuilder sb = new StringBuilder();
char[] cbuf = new char[1024];
int len = 0;
while(br.ready() && (len = br.read(cbuf)) > 0){
br.read(cbuf);
sb.append(cbuf, 0, len);
}
String reg = "\r\n\r\n";
System.out.println("原內(nèi)容：\n" + sb.toString());
System.out.println("處理后：-----------------------------");
System.out.println(sb.toString().replaceAll(reg, "\r\n"));
}
運(yùn)行結(jié)果如下：
原內(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
三、匹配特定的字符類別
字符集合（匹配多個(gè)字符中的某一個(gè)）是最常見的匹配形式，而一些常用的字符集合可以用特殊元字符來代替。這些元字符匹配的是某一類別的字符（類元字符），類元字符并不是必不可少的，因?yàn)榭梢酝ㄟ^逐一列舉有關(guān)字符或通過定義一個(gè)字符區(qū)間來匹配某一類字符，但是使用它們構(gòu)造出來的正則表達(dá)式簡明易懂，在實(shí)際應(yīng)用中很常用。
1、匹配數(shù)字與非數(shù)字
\d 任何一個(gè)數(shù)字，等價(jià)于[0-9]或[0123456789]
\D 任何一個(gè)非數(shù)字，等價(jià)于[^0-9]或[^0123456789]
2、匹配字母和數(shù)字與非字母和數(shù)字
字母（A-Z不區(qū)分大小寫）、數(shù)字、下劃線是一種常用的字符集合，可用如下類元字符：
\w 任何一個(gè)字母（不區(qū)分大小寫）、數(shù)字、下劃線，等價(jià)于[0-9a-zA-Z_]
\W 任何一個(gè)非字母數(shù)字和下劃線，等價(jià)于[^0-9a-zA-Z_]
3、匹配空白字符與非空白字符
\s 任何一下空白字符，等價(jià)于[\f\n\r\t\v]
\S 任何一下空白字符，等價(jià)于[^\f\n\r\t\v]
注意：退格元字符\b沒有不在\s的范圍之內(nèi)。
4、匹配十六進(jìn)制或八進(jìn)制數(shù)值
十六進(jìn)制：用前綴\x來給出，如：\x0A對應(yīng)于ASCII字符10（換行符），其效果等價(jià)于\n。
八進(jìn)制：用前綴\0來給出，數(shù)值本身可以是兩位或三位數(shù)字，如：\011對應(yīng)于ASCII字符9（制表符），其效果等價(jià)于\t。
四、使用POSIX字符類
POSIX字符類是很多正則表達(dá)式實(shí)現(xiàn)都支持的一種簡寫形式。Java也支持它，但JavaScript不支持。POSIX字符如下所示：
[:alnum:] 任何一個(gè)字母或數(shù)字，等價(jià)于[a-zA-Z0-9]
[:alpha:] 任何一個(gè)字母，等價(jià)于[a-zA-Z]
[:blank:] 空格或制表符，等價(jià)于[\t]
[:cntrl:] ASCII控制字符（ASCII 0到31，再加上ASCII 127）
[:digit:] 任何一個(gè)數(shù)字，等價(jià)于[0-9]
[:graph:] 任何一個(gè)可打印字符，但不包括空格
[:lower:] 任何一個(gè)小寫字母，等價(jià)于[a-z]
[:print:] 任何一個(gè)可打印字符
[:punct:] 既不屬于[:alnum:]和[:cntrl:]的任何一個(gè)字符
[:space:] 任何一個(gè)空白字符，包括空格，等價(jià)于[^\f\n\r\t\v]
[:upper:] 任何一個(gè)大寫字母，等價(jià)于[A-Z]
[:xdigit:] 任何一個(gè)十六進(jìn)制數(shù)字，等價(jià)于[a-fA-F0-9]
POSIX字符和之前見過的元字符不太一樣，我們來看一個(gè)前面利用正則表達(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字符必須括在[:和:]之間，外層[和]字符用來定義一個(gè)集合，內(nèi)層的[和]字符是POSIX字符類本身的組成部分。
在java中的POSIX字符表示有所不同，不是包括在[:和:]之間，而是以\p開頭，包括在{和}之間，且大小寫有區(qū)別，同時(shí)增加了\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]
一、final
根據(jù)程序上下文環(huán)境，Java關(guān)鍵字final有“這是無法改變的”或者“終態(tài)的”含義，它可以修飾非抽象類、非抽象類成員方法和變量。你可能出于兩種理解而需要阻止改變：設(shè)計(jì)或效率。
final類不能被繼承，沒有子類，final類中的方法默認(rèn)是final的。
final方法不能被子類的方法覆蓋，但可以被繼承。
final成員變量表示常量，只能被賦值一次，賦值后值不再改變。
final不能用于修飾構(gòu)造方法。
注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認(rèn)是final類型的。
1、final類
final類不能被繼承，因此final類的成員方法沒有機(jī)會(huì)被覆蓋，默認(rèn)都是final的。在設(shè)計(jì)類時(shí)候，如果這個(gè)類不需要有子類，類的實(shí)現(xiàn)細(xì)節(jié)不允許改變，并且確信這個(gè)類不會(huì)載被擴(kuò)展，那么就設(shè)計(jì)為final類。
2、final方法
如果一個(gè)類不允許其子類覆蓋某個(gè)方法，則可以把這個(gè)方法聲明為final方法。
使用final方法的原因有二：
第一、把方法鎖定，防止任何繼承類修改它的意義和實(shí)現(xiàn)。
第二、高效。編譯器在遇到調(diào)用final方法時(shí)候會(huì)轉(zhuǎn)入內(nèi)嵌機(jī)制，大大提高執(zhí)行效率。
例如：
public class Test1 {
public static void main(String[] args) {
// TODO 自動(dòng)生成方法存根
}
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變量定義的時(shí)候，可以先聲明，而不給初值，這中變量也稱為final空白，無論什么情況，編譯器都確保空白final在使用之前必須被初始化。但是，final空白在final關(guān)鍵字final的使用上提供了更大的靈活性，為此，一個(gè)類中的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空白,必須在初始化對象的時(shí)候賦初值
public Test3(int x){
E=x;
}
/**
* @param args
*/
public static void main(String[] args) {
Test3 t=new Test3(2);
//t.A=101; //出錯(cuò),final變量的值一旦給定就無法改變
//t.B=91; //出錯(cuò),final變量的值一旦給定就無法改變
//t.C=81; //出錯(cuò),final變量的值一旦給定就無法改變
//t.D=71; //出錯(cuò),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); //出錯(cuò),因?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空白,在需要的時(shí)候才賦值
final int b=4; //局部常量--final用于局部變量的情形
final int c; //final空白,一直沒有給賦值.
a=3;
//a=4; 出錯(cuò),已經(jīng)給賦過值了.
//b=2; 出錯(cuò),已經(jīng)給賦過值了.
}
} |
4、final參數(shù)
當(dāng)函數(shù)參數(shù)為final類型時(shí)，你可以讀取使用該參數(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í)例共享。只要這個(gè)類被加載，Java虛擬機(jī)就能根據(jù)類名在運(yùn)行時(shí)數(shù)據(jù)區(qū)的方法區(qū)內(nèi)定找到他們。因此，static對象可以在它的任何對象創(chuàng)建之前訪問，無需引用任何對象。
用public修飾的static成員變量和成員方法本質(zhì)是全局變量和全局方法，當(dāng)聲明它類的對象市，不生成static變量的副本，而是類的所有實(shí)例共享同一個(gè)static變量。
static變量前可以有private修飾，表示這個(gè)變量可以在類的靜態(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）加載類時(shí)，就會(huì)執(zhí)行該代碼塊（用處非常大，呵呵）。
1、static變量 按照是否靜態(tài)的對類成員變量進(jìn)行分類可分兩種：一種是被static修飾的變量，叫靜態(tài)變量或類變量；另一種是沒有被static修飾的變量，叫實(shí)例變量。兩者的區(qū)別是：
對于靜態(tài)變量在內(nèi)存中只有一個(gè)拷貝（節(jié)省內(nèi)存），JVM只為靜態(tài)分配一次內(nèi)存，在加載類的過程中完成靜態(tài)變量的內(nèi)存分配，可用類名直接訪問（方便），當(dāng)然也可以通過對象來訪問（但是這是不推薦的）。
對于實(shí)例變量，沒創(chuàng)建一個(gè)實(shí)例，就會(huì)為實(shí)例變量分配一次內(nèi)存，實(shí)例變量可以在內(nèi)存中有多個(gè)拷貝，互不影響（靈活）。
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)！這個(gè)需要去理解，想明白其中的道理，不是記憶！！！
因?yàn)閟tatic方法獨(dú)立于任何實(shí)例，因此static方法必須被實(shí)現(xiàn)，而不能是抽象的abstract。
3、static代碼塊 static代碼塊也叫靜態(tài)代碼塊，是在類中獨(dú)立于類成員的static語句塊，可以有多個(gè)，位置可以隨便放，它不在任何的方法體內(nèi)，JVM加載類時(shí)會(huì)執(zhí)行這些靜態(tài)的代碼塊，如果static代碼塊有多個(gè)，JVM將按照它們在類中出現(xiàn)的先后順序依次執(zhí)行它們，每個(gè)代碼塊只會(huì)被執(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 自動(dòng)生成方法存根
}
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)行賦值，最后再看一眼這些例子，都一個(gè)static的main方法，這樣JVM在運(yùn)行main方法的時(shí)候可以直接調(diào)用而不用創(chuàng)建實(shí)例。
4、static和final一塊用表示什么 static final用來修飾成員變量和成員方法，可簡單理解為“全局常量”！
對于變量，表示一旦給值就不可修改，并且通過類名可以訪問。
對于方法，表示不可覆蓋，并且可以通過類名直接訪問。
什么是ThreadLocal？
顧名思義它是local variable（線程局部變量）。它的功用非常簡單，就是為每一個(gè)使用該變量的線程都提供一個(gè)變量值的副本，是每一個(gè)線程都可以獨(dú)立地改變自己的副本，而不會(huì)和其它線程的副本沖突。從線程的角度看，就好像每一個(gè)線程都完全擁有該變量。
使用場景
- To keep state with a thread (user-id, transaction-id, logging-id)
- To cache objects which you need frequently
ThreadLocal類
它主要由四個(gè)方法組成initialValue()，get()，set(T)，remove()，其中值得注意的是initialValue()，該方法是一個(gè)protected的方法，顯然是為了子類重寫而特意實(shí)現(xiàn)的。該方法返回當(dāng)前線程在該線程局部變量的初始值，這個(gè)方法是一個(gè)延遲調(diào)用方法，在一個(gè)線程第1次調(diào)用get()或者set(Object)時(shí)才執(zhí)行，并且僅執(zhí)行1次。ThreadLocal中的確實(shí)實(shí)現(xiàn)直接返回一個(gè)null：
ThreadLocal的原理
ThreadLocal是如何做到為每一個(gè)線程維護(hù)變量的副本的呢？其實(shí)實(shí)現(xiàn)的思路很簡單，在ThreadLocal類中有一個(gè)Map，用于存儲每一個(gè)線程的變量的副本。比如下面的示例實(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的文檔時(shí)看到了關(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。 初始化一個(gè)ThreadLocal對象，ThreadLocal有三個(gè)成員方法 get()、set()、initialvalue()。
如果不初始化initialvalue，則initialvalue返回null。
3。session的get根據(jù)當(dāng)前線程返回其對應(yīng)的線程內(nèi)部變量，也就是我們需要的net.sf.hibernate.Session（相當(dāng)于對應(yīng)每個(gè)數(shù)據(jù)庫連接）.多線程情況下共享數(shù)據(jù)庫鏈接是不安全的。ThreadLocal保證了每個(gè)線程都有自己的s（數(shù)據(jù)庫連接）。
5。如果是該線程初次訪問，自然，s（數(shù)據(jù)庫連接）會(huì)是null，接著創(chuàng)建一個(gè)Session，具體就是行6。
6。創(chuàng)建一個(gè)數(shù)據(jù)庫連接實(shí)例 s
7。保存該數(shù)據(jù)庫連接s到ThreadLocal中。
8。如果當(dāng)前線程已經(jīng)訪問過數(shù)據(jù)庫了，則從session中g(shù)et()就可以獲取該線程上次獲取過的連接實(shí)例。
使用方法二
當(dāng)要給線程初始化一個(gè)特殊值時(shí)，需要自己實(shí)現(xiàn)ThreadLocal的子類并重寫該方法，通常使用一個(gè)內(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對象的線程局部變量，這個(gè)變
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)上面這樣的功能，最簡單的想法是用一個(gè)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的效果，但是有一個(gè)問題，當(dāng)對應(yīng)的線程消失后，map中對應(yīng)的線程值并不會(huì)被回收，從而造成內(nèi)存泄露。
事實(shí)上ThreadLocal是這樣做的：
每個(gè)Thread都有一個(gè)threadLocalMap，key是threadLocal對象，value是具體使用的值。ThreadLocal對象的get就是先取得當(dāng)前的Thread，然后從這個(gè)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)的值，會(huì)調(diào)用setInitialValue();，最終調(diào)用initialValue()生成一個(gè)值，這也是我們很多場景下要override這個(gè)方法的原因；
下面看一下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對象也被回收，這時(shí)對應(yīng)的ThreadLocal對象(該線程部分)也會(huì)被回收。
這里為什么是一個(gè)ThreadLocalMap呢，因?yàn)橐粋€(gè)線程可以有多個(gè)ThreadLocal變量，通過map.getEntry(this)取得對應(yīng)的某個(gè)具體的變量。
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是一個(gè)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對象，如果某個(gè)ThreadLocal對象所有的強(qiáng)引用沒有了，會(huì)利用weakref的功能把他回收掉，然后復(fù)用這個(gè)entry。
考慮一下如果不用weakReference會(huì)出現(xiàn)什么情況：假設(shè)某個(gè)對象是這樣引用的
private final ThreadLocal<String> globalName = new ThreadLocal<String>();
注意沒有static，然后這個(gè)對象被不斷的new出來，然后死掉，每次ThreadLocalmap中都會(huì)多出一個(gè)entry，然后這個(gè)entry強(qiáng)引用一個(gè)ThreadLocal對象，ThreadLocalMap本身就沒有辦法確定哪個(gè)entry是不用了的，如果恰好這個(gè)線程是線程池中的，會(huì)存活很久，那就杯具了。
ThreadLocalMap用了weakReference，失去強(qiáng)引用的ThreadLocal對象會(huì)在下次gc時(shí)被回收，然后ThreadLocalMap本身在get和set的時(shí)候會(huì)考察key為空的Entry，并復(fù)用它或者清除，從而避免內(nèi)存泄露。
這樣看來，HashMap也有一樣的問題，但為什么hashMap不這樣呢，因?yàn)閔ashMap的put是業(yè)務(wù)代碼操作的，因此如果有長期存活的HashMap，（比如static的）業(yè)務(wù)代碼put進(jìn)去就有義務(wù)去remove，但ThreadLocal的put操作時(shí)ThreadLocal類干的，業(yè)務(wù)代碼不知道，因此也不會(huì)去做remove，而ThreadLocalMap本身不知道引用他的某個(gè)entry的key的對象什么時(shí)候死掉了，那么如果不用弱引用，就不知道這個(gè)ThreadLocal對象什么時(shí)候需要回收了。
附：
這里補(bǔ)充一下weakReference的用法供參考（當(dāng)強(qiáng)引用不存在時(shí)，下次垃圾回收會(huì)回收弱引用所引用的對象）：
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>();
}
answer:事實(shí)上，不一定是要static，但使用它的對象在業(yè)務(wù)需要范圍類一定要是單例。因?yàn)楦鶕?jù)前面的分析，ThreadLocalMap是以ThreadLocal對象為key的，如果Test類不是static，也不是單例的，那么兩個(gè)Test對象就有兩個(gè)key，取出來的數(shù)據(jù)肯定不同
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();
}
輸出將會(huì)是：a，null
原因就無需多解釋了。唯一需要啰嗦的一點(diǎn)是，就算一般情況都是單例，上面那個(gè)weakreference還是必要的，因?yàn)樽鳛榭蚣艽a，不能保證正常使用的情況下一個(gè)線程有很多ThreadLocal，如果不用weakreference，就會(huì)有內(nèi)存泄漏的風(fēng)險(xiǎn)，特別是針對線程池中的線程。
摘要: 轉(zhuǎn)載：http://www.tkk7.com/f6k66ve/archive/2012/05/30/379516.htmlSpring配置文件中關(guān)于事務(wù)配置總是由三個(gè)組成部分，分別是DataSource、TransactionManager和代理機(jī)制這三部分，無論哪種配置方式，一般變化的只是代理機(jī)制這部分。
DataSource、TransactionManager這兩部分只是會(huì)根...
閱讀全文