2012年7月12日

js通過ajax傳給后臺一個json數組字符串：

[{'prjcode':'4209222012A00','countyname':'大悟縣','pro_1':'A','pro_2':'A','pro_3':'A','pro_4':'A','pro_5':'A','pro_6':'A','pro_7':'A','pro_8':'A','pro_9':'A','pro_10':'A','pro_11':'A','pro_12':'A','pro_13':'A','pro_14':'A','pro_15':'A'},{'prjcode':'4209222005A03','countyname':'大悟縣','pro_1':'A','pro_2':'A','pro_3':'A','pro_4':'A','pro_5':'A','pro_6':'A','pro_7':'A','pro_8':'A','pro_9':'A','pro_10':'A','pro_11':'A','pro_12':'A','pro_13':'A','pro_14':'A','pro_15':'A'},{'prjcode':'4209222005B00','countyname':'大悟縣','pro_1':'A','pro_2':'A','pro_3':'A','pro_4':'A','pro_5':'A','pro_6':'A','pro_7':'A','pro_8':'A','pro_9':'A','pro_10':'A','pro_11':'A','pro_12':'A','pro_13':'A','pro_14':'A','pro_15':'A'}]

后臺接受進行遍歷存儲

String jsonstr = request.getParameter("jsonstr");
            JSONArray json = JSONArray.fromObject(jsonstr);
            Object[] obj=json.toArray();
            for(int i=0;i<obj.length;i++){
              JSONObject object = JSONObject.fromObject(obj[i]);
              String prjcode=object.get("prjcode").toString();
              String countyname=object.getString("countyname").toString();
              String pro_1=object.getString("pro_1").toString();
              String pro_2=object.getString("pro_2").toString();
              String pro_3=object.getString("pro_3").toString();
              String pro_4=object.getString("pro_4").toString();
              String pro_5=object.getString("pro_5").toString();
              String pro_6=object.getString("pro_6").toString();
              String pro_7=object.getString("pro_7").toString();
              String pro_8=object.getString("pro_8").toString();
              String pro_9=object.getString("pro_9").toString();
              String pro_10=object.getString("pro_10").toString();
              String pro_11=object.getString("pro_11").toString();
              String pro_12=object.getString("pro_12").toString();
              String pro_13=object.getString("pro_13").toString();
              String pro_14=object.getString("pro_14").toString();
              String pro_15=object.getString("pro_15").toString();
            }

posted @ 2012-08-16 22:36 zhanghu198901 閱讀(2485) | 評論 (0) | 編輯收藏

DIV +CSS 系列詳細教程（一）初識

CSS之所以會如此流行，是它具備以下的優點

      1、符合W3C標準。保證網站不會因為將來網絡應用的升級而被淘汰。
    2、支持瀏覽器的向后兼容，也就是無論未來的瀏覽器大戰，勝利的是IE、chrome或者是火狐，網站都能很好的兼容。
     3、搜索引擎更加友好。相對與傳統的table, 采用DIV+CSS技術的網頁，更加容易被搜索引擎找到。
     4、樣式的調整更加方便。內容和樣式的分離，使頁面和樣式的調整變得更加方便，可以一次性修改多個網頁的樣式，只修改樣式不需要重新發布。
     5、降低網頁大小，對于一個大型網站來說，可以節省大量帶寬，大大提高用戶體驗，這是非常重要的一點——用戶至上。

posted @ 2012-08-16 22:36 zhanghu198901 閱讀(1119) | 評論 (0) | 編輯收藏

Struts2結合jquery autocomplet插件實現自動提示詳解

在網上會有很多關于struts2結合autocomplet插件的實例，但是不怎么完整，讓人感覺不清楚，剛剛在公司做了一個關于這個的項目，頁面也用到了這個插件，所以把詳細的步驟和注意事項貼出來和大家分享，廢話不多說，貼鐵代碼：本文代碼下載地址：http://download.csdn.net/detail/harderxin/4504612

一、我的資源中有autcomplet的json實例和autocomplet的源代碼，也是copy網上的，大家可以免費下載，下載地址：http://download.csdn.net/detail/harderxin/4504288

二、開始我們的案例旅程

1、編寫頁面index.jsp

顯示效果如下：

posted @ 2012-08-16 22:34 zhanghu198901 閱讀(1264) | 評論 (0) | 編輯收藏

正則表達式學習--元字符的使用

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

一、對特殊字符進行轉義

元字符是一些在正則表達式里有著特殊含義的字符。因為元字符在正則表達式里有著特殊的含義，所以這些字符就無法用來代表它們本身。在元字符前面加上一個反斜杠就可以對它進行轉義，這樣得到的轉義序列將匹配那個字符本身而不是它特殊的元字符含義。如，如果想要匹配[和]，就必須對它進行轉義：\[和\]。

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

二、匹配空白字符

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

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

\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

正則表達式：\r\n\r\n

分析：\r\n匹配一個回車+換行組合，windows操作系統中把它作為文本行的結束標簽。使用正則表達式\r\n\r\n進行的搜索將匹配兩個連續的行尾標簽，而這正好是空白行。

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

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" + sb.toString());
        System.out.println("處理后：-----------------------------");
        System.out.println(sb.toString().replaceAll(reg, "\r\n"));
    }

運行結果如下：

原內容：

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

三、匹配特定的字符類別

字符集合（匹配多個字符中的某一個）是最常見的匹配形式，而一些常用的字符集合可以用特殊元字符來代替。這些元字符匹配的是某一類別的字符（類元字符），類元字符并不是必不可少的，因為可以通過逐一列舉有關字符或通過定義一個字符區間來匹配某一類字符，但是使用它們構造出來的正則表達式簡明易懂，在實際應用中很常用。

1、匹配數字與非數字

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

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

2、匹配字母和數字與非字母和數字

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

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

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

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

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

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

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

4、匹配十六進制或八進制數值

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

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

四、使用POSIX字符類

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

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

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

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

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

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

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

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

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

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

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

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

[:xdigit:] 任何一個十六進制數字，等價于[a-fA-F0-9]

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

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

正則表達式：#[[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]]

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

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

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

\p{Alnum} 字母數字字符：[\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} 十進制數字：[0-9]

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

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

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

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

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

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

\p{XDigit} 十六進制數字：[0-9a-fA-F]

posted @ 2012-08-12 23:00 zhanghu198901 閱讀(2096) | 評論 (2) | 編輯收藏

正則表達式學習---重復匹配

一、有多少個匹配

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

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

1、匹配一個或多個字符

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

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

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

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

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

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

2、匹配零個或多個字符

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

3、匹配零個或一個字符

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

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

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

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

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

二、匹配的重復次數

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

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

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

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

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

1、為重復匹配次數設定一個精確值

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

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

2、為重復匹配次數設定一個區間

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

3、匹配至少重復多少次

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

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

文本：

$25.36

$125.36

$205.0

$2500.44

$44.30

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

結果：

$25.36

【$125.36】

【$205.0】

【$2500.44】

$44.30

+、*、?可以表示成重復次數：

+等價于{1,}

*等價于{0,}

?等價于{0,1}

三、防止過度匹配

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

來看匹配一個html標簽的例子

文本：

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

正則表達式：<[Bb]>.*</[Bb]>

結果：

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

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

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

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

* *?

+ +?

{n,} {n,}?

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

<b>history</b>

<B>mystery</B>

四、總結

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

posted @ 2012-08-12 23:00 zhanghu198901 閱讀(13331) | 評論 (1) | 編輯收藏

開發經理（技術型）需要做的第一件事情

根據我近些年在IT行業的摸爬滾打，發現作為一個合格的開發經理需要做的第一件事情是：規范。

1、規范代碼

每個公司都有自己的規范文檔，但是很少有同學按照規范標準來寫自己的代碼。這樣導致代碼風格多元化、代碼邏輯可愛化，更有甚者，會有人連自己的代碼都看不懂。為什么？原因很簡單，雖然寫了規范文檔，做了規范培訓，但是沒有強制的執行和跟蹤。

我認為作為一個合格的開發經理，需要做如下三件事情。第一步，寫代碼規范文檔，做培訓。第二步，按照規范生成開發模版，規定手下的所有開發人員的開發工具中導入此模版。第三步，反復核查開發人員的代碼（3-6個月），直到規范成為一種習慣。

2、規范文檔

文檔在中國IT公司幾乎不受太大的重視。

在項目型的公司，要么就是沒有文檔，要么就是文檔泛濫（要知道，有很多文檔是做給QA看的，其實都是垃圾），我有時候就想，這樣有意義嗎？文檔的目的是開發人員的輔助工具，尤其對于剛入職公司的新人而言，不會有幾個“好心腸”的老員工去幫助新員工講解項目架構和原理的，進來了就是靠自己摸索，那么文檔對于新人就顯得尤為重要了。所以，要么就建立一個好的培訓機制，要么就寫好文檔，如果兩者都做的很好為最佳。

在互聯網公司，對于一些生命周期短暫的小項目不寫文檔我同意，畢竟需要時間成本。但是這樣的項目代碼規范一定嚴格，盡量精細到數據庫字段的規范。因為這種類型的項目開發人員一般為1人，如果此人離開，后來人員交接時，能夠更快的看懂對方的代碼，以節省時間。此外，對于核心項目，一定需要一套完整的API文檔，以供各項目組之間的互通，減少不必要的溝通。

總結：正是因為沒有合理的規范，某個模塊的開發人員離職，會消耗公司的巨大維護成本。如果能夠做到以上兩點規范，相信能夠給公司帶來更多的效能。

posted @ 2012-08-12 22:58 zhanghu198901 閱讀(1892) | 評論 (1) | 編輯收藏

修改 mysql root 密碼

如果 mysql 是剛安裝，那么 root 的密碼默認為空。可以使用以下方法修改密碼：

Java代碼  
mysqladmin -u root password PASSWORD  

如果 root 有密碼，那么使用以下命令修改：

Java代碼  
mysqladmin -u root -p'oldpassword' password newpass  

另外還可以通過登錄 sql 控制臺后修改：

Sql代碼  
update user set password=PASSWORD("NEWPASSWORD") where User='root';  
flush privileges;  

posted @ 2012-07-21 22:16 zhanghu198901 閱讀(853) | 評論 (0) | 編輯收藏

android push notification serfice android中的push機制

APNS 是什么?

APNS (Android Push Notification Service) 是一種在 android 上輕松實現 push notification 的功能的解決方案. 只需申請一個 API Key, 經過簡單的步驟即可實現 push notification 的功能.

特點:

快速集成:提供一種比C2DM更加快捷的使用方式,避免各種限制.

無需架設服務器:通過使用"云服務",減少額外服務器負擔.

可以同時推送消息到網站頁面,android 手機

耗電少,占用流量少.

http://zen-mobi.com/get_api_key.php獲取apikey

如何在 Android 應用中使用 Notification ？

a) 在應用中添加 APNS 功能

下載 libaray: com_apns.jar
將com_apns.jar添加到工程

在工程上右鍵打開“屬性”,選擇 “Java Build Path”, 在 Libraries 中選擇 “Add External JARs”, 選擇下載的 com_apns.jar.

接收 push notification

使用BroadcastReceiver接收系統廣播:  public class MyBroadcastReceiver extends BroadcastReceiver { 	@Override 	public void onReceive(Context context, Intent intent) { 	     if (intent.getAction().equals(APNService.ON_NOTIFICATION)) { 			String str = intent.getStringExtra("data"); 			//todo, 處理收到的消息 		 }  	} }

啟動 Push Notification Service

發送Intent 啟動服務，將 chanel Id 以及 此設備的標識 (chanel中唯一表示此設備的字符串) 傳遞過去:       Intent intent = new Intent(APNService.START);     intent.putExtra("ch", chanel);     intent.putExtra("devId", devId);     startService(intent);

Notes

配置 AndroidManifest.xml

... <application android:icon="@drawable/icon"  	   ...  	 <service android:name="com.apns.APNSService" android:label="APNS">          <intent-filter>              <action android:name="com.apns.APNService.START" />              <action android:name="com.apns.APNService.STOP" />              <category android:name="android.intent.category.DEFAULT"/>          </intent-filter> 	 </service> 	 <receiver android:name="MyBroadcastReceiver"> 	      <intent-filter> 	          <action android:name="com.apnsd.APNService.NOTIFICATION" /> 	      </intent-filter> 	 </receiver>	 </application>	 <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> ...

b) 發送 Notification 到設備

通過 rest 接口發送 Notification:
http://www.push-notification.org/handlers/apns_v1.php?ch=YourChannelId&devId=xxxxx&msg =hello world&random=0123&hash=HashCode

ch:Channel Id devId:接收設備 Id msg:消息 random:隨機數 hash:md5(ch + devId + msg + random + apiKey)

posted @ 2012-07-21 22:15 zhanghu198901 閱讀(1746) | 評論 (1) | 編輯收藏

android中置調用指定瀏覽器

默認的瀏覽器都列出讓用戶選擇的

Java代碼

Uri u = Uri.parse(url);

Intent it = new Intent(Intent.ACTION_VIEW, url); TestActivity.this.startActivity(it);

Uri u = Uri.parse(url);

Intent it = new Intent(Intent.ACTION_VIEW, url); TestActivity.this.startActivity(it);

指定瀏覽器的

Java代碼

Uri u = Uri.parse(url);

it.setData(u);

it.setAction( Intent.ACTION_VIEW);

it.setClassName("com.android.browser","com.android.browser.BrowserActivity");

TestActivity.this.startActivity(it);

posted @ 2012-07-21 22:15 zhanghu198901 閱讀(1664) | 評論 (1) | 編輯收藏

Java 多線程編程

1) 程序: 指令+數據的byte 序列, 如: qq.exe
2) 進程: 正在運行的程序, 是程序動態的執行過程(運行于主存儲器)
3) 線程: 在進程內部, 并發運程的過程(方法)
4) 并發: 進程是并發運行的, OS 將時間劃分為很多時間片段, 盡可能
均勻分配給正在運行的程序, 微觀上進程走走停停, 宏觀上都在運行
這種都運行的現象叫: 并發, 但是不是絕對意義上的"同時"

posted @ 2012-07-18 21:35 zhanghu198901 閱讀(1071) | 評論 (2) | 編輯收藏

一種非遞歸深度遍歷

算法比較簡單，沒有采用遞歸，javascript實現如下，可以輕易轉為其他語言

posted @ 2012-07-18 21:34 zhanghu198901 閱讀(726) | 評論 (0) | 編輯收藏

spring的三種注入方式

spring 的三種注入方式

1. 接口注入（不推薦）

2. getter ， setter 方式注入（比較常用）

3. 構造器注入（死的應用）

關于 getter 和 setter 方式的注入

· autowire="defualt"

· autowire=“byName”

· autowire="bytype"

詳細解析注入方式

例如：有如下兩個類需要注入

第一個類：

Java代碼
package  org.jia;  
    
  public   class  Order {  
      private  String orderNum;  
      @SuppressWarnings ( "unused" )  
      private  OrderItem orderitem;  
    
      public  OrderItem getOrderitem() {  
          return  orderitem;  
     }  
   
     public   void  setOrderitem(OrderItem orderitem) {  
         this .orderitem = orderitem;  
     }  
   
     public  String getOrderNum() {  
         return  orderNum;  
     }  
   
     public   void  setOrderNum(String orderNum) {  
         this .orderNum = orderNum;  
     }       
 }  

第二個類：

Java代碼
package  org.jia;  
   
 public   class  OrderItem {  
     private  String orderdec;  
   
     public  String getOrderdec() {  
         return  orderdec;  
     }  
   
     public   void  setOrderdec(String orderdec) {  
         this .orderdec = orderdec;  
     }  
 }  

常用getter&&setter方式介紹

方式第一種注入：

Html代碼
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
  
< beans >   
    < bean   id = "orderItem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order"   >   
        <!-----注入變量 名字必須與類中的名字一樣------->   
        < property   name = "orderNum"   value = "order000007" > </ property >   
         < ！--注入對象 名字為orderitem，所屬的類的應用id為orderItem-- >   
        < property   name = "orderitem"   ref = "orderItem" > </ property >   
      
    --> </ bean >   
</ beans >   

方式第二種注入： byName

Html代碼
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
< beans >   
    <!--此時的id就必須與Order.java中所定義的OrderItem的對象名稱一樣了，不然就會找不到-->   
    < bean   id = "orderitem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order" < span   style = "color: #ff0000;" >   autowire = "byName" </ span > >   
        < property   name = "orderNum"   value = "order000007" > </ property >   
    </ bean >   
</ beans >   

方式第三種注入： byType

Html代碼
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
< beans >   
    <!--按照byType注入則就與id沒有關系，可以隨便定義id ！！！但是不能出現多個此類的id-->   
    < bean   id = "orderitdfadafaem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order"   < span   style = "color: #ff0000;" > autowire = "byType" </ span > >   
        < property   name = "orderNum"   value = "order000007" > </ property >   
    </ bean >   
</ beans >   

autowire="constructor"
需要在 Order.java 中加入一個構造器

Java代碼
public  Order(OrderItem item )  
{   
      orderitem = item;  
}  

XML配置文件

Html代碼
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
< beans >   
    < bean   id = "orderItem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order"   autowire = "constructor" >   
        < property   name = "orderNum"   value = "order000007" > </ property >   
    </ bean >   
</ beans >   

三種注入方式比較

接口注入：
接口注入模式因為具備侵入性，它要求組件必須與特定的接口相關聯，因此并不被看好，實際使用有限。
Setter 注入：
對于習慣了傳統 javabean 開發的程序員，通過 setter 方法設定依賴關系更加直觀。
如果依賴關系較為復雜，那么構造子注入模式的構造函數也會相當龐大，而此時設值注入模式則更為簡潔。
如果用到了第三方類庫，可能要求我們的組件提供一個默認的構造函數，此時構造子注入模式也不適用。
構造器注入：
在構造期間完成一個完整的、合法的對象。
所有依賴關系在構造函數中集中呈現。
依賴關系在構造時由容器一次性設定，組件被創建之后一直處于相對“不變”的穩定狀態。
只有組件的創建者關心其內部依賴關系，對調用者而言，該依賴關系處于“黑盒”之中。

總結

Spring使用注入方式，為什么使用注入方式，這系列問題實際歸結起來就是一句話，Spring的注入和IoC （本人關于IoC的闡述）反轉控制是一回事。

理論上：第三種注入方式（構造函數注入）在符合java使用原則上更加合理，第二種注入方式（setter注入）作為補充。

posted @ 2012-07-18 21:33 zhanghu198901 閱讀(1328) | 評論 (0) | 編輯收藏

jquery學習心得（二）：一個很好的css和js函數調用的例子

統一目錄下的資源結構圖：

<html>
<head>
<link rel="stylesheet" href="gallery.css" type="text/css" media="screen" charset="utf-8"/>
<script type="text/javascript" src="script.js"></script>
</head>

<body>
    <div id="container">
        <div id="header">
            <h1>StarTrackr!</h1>
    </div>
        <div id="content">
            <h2>Around Town Last Night</h2>

            <div id="ajaxInProgress"></div>
            <div id="photos">
                <fieldset id="photoDetails">
                    <legend>Photo Tagging</legend>
                    <form id="details">
                        <p id="status"></p>
                        <p>
                            <label for="name">Name:</label><br/>
                            <input type="text" class="textField" name="name" id="name" />
                        </p>
                        <p>
                            <label for="tags">Tags:</label><br/>
                            <input type="text" class="textField" name="tags" id="tags" />
                        </p>
                        <p>
                            <input type="hidden" name="id" id="id">
                            <input type="button" value="update" id="update" />
                        </p>
                    </form>
                    <div id="gallery"></div>
                </fieldset>
            </div>
   </div>
</div>
</body>
</html>

posted @ 2012-07-18 21:32 zhanghu198901 閱讀(876) | 評論 (0) | 編輯收藏

Java程序員不該有的6種陋習

只有在學會處理異常之后，我們才能說自己是一個合格的java程序員。只有在擺脫了以下六種異常處理的陋習之后，才能威懾一下剛畢業的小菜鳥。

　　現在就來測試一下大家對異常的掌握程度。不用擔心，事實上，這些不合理的設計很容易看出來。那么，以下六種不合理的代碼，大家能看出每一種的問題出在哪兒嗎？

　　OutputStreamWriter out = ...

　　java.sql.Connection conn = ...

　　try { // ⑸

　　Statement stat = conn.createStatement();

　　ResultSet rs = stat.executeQuery(

　　"select uid, name from user");

　　while (rs.next())

　　{

　　out.println("ID：" + rs.getString("uid") // ⑹

　　+ "，姓名：" + rs.getString("name"));

　　}

　　conn.close(); // ⑶

　　out.close();

　　}

　　catch(Exception ex) // ⑵

　　{

　　ex.printStackTrace(); //⑴，⑷

　　}

　　作為一個Java程序員，你至少應該能夠找出兩個問題。但是，如果你不能找出全部六個問題，請繼續閱讀本文。

　　本文討論的不是Java異常處理的一般性原則，因為這些原則已經被大多數人熟知。我們要做的是分析各種可稱為“反例”(anti-pattern)的違背優秀編碼規范的常見壞習慣，幫助讀者熟悉這些典型的反面例子，從而能夠在實際工作中敏銳地察覺和避免這些問題。

　　反例之一：丟棄異常

　　代碼：15行-18行。

　　這段代碼捕獲了異常卻不作任何處理，可以算得上Java編程中的殺手。從問題出現的頻繁程度和禍害程度來看，它也許可以和C/C++程序的一個惡名遠播的問題相提并論？？不檢查緩沖區是否已滿。如果你看到了這種丟棄(而不是拋出)異常的情況，可以百分之九十九地肯定代碼存在問題(在極少數情況下，這段代碼有存在的理由，但最好加上完整的注釋，以免引起別人誤解)。

　　這段代碼的錯誤在于，異常(幾乎)總是意味著某些事情不對勁了，或者說至少發生了某些不尋常的事情，我們不應該對程序發出的求救信號保持沉默和無動于衷。調用一下printStackTrace算不上“處理異常”。不錯，調用printStackTrace對調試程序有幫助，但程序調試階段結束之后，printStackTrace就不應再在異常處理模塊中擔負主要責任了。

　　丟棄異常的情形非常普遍。打開JDK的ThreadDeath類的文檔，可以看到下面這段說明：“特別地，雖然出現ThreadDeath是一種‘正常的情形’，但ThreadDeath類是Error而不是Exception的子類，因為許多應用會捕獲所有的Exception然后丟棄它不再理睬。”這段話的意思是，雖然ThreadDeath代表的是一種普通的問題，但鑒于許多應用會試圖捕獲所有異常然后不予以適當的處理，所以JDK把 ThreadDeath定義成了Error的子類，因為Error類代表的是一般的應用不應該去捕獲的嚴重問題。可見，丟棄異常這一壞習慣是如此常見，它甚至已經影響到了Java本身的設計。

　　那么，應該怎樣改正呢？主要有四個選擇：

　　1、處理異常。針對該異常采取一些行動，例如修正問題、提醒某個人或進行其他一些處理，要根據具體的情形確定應該采取的動作。再次說明，調用printStackTrace算不上已經“處理好了異常”。

　　2、重新拋出異常。處理異常的代碼在分析異常之后，認為自己不能處理它，重新拋出異常也不失為一種選擇。

　　3、把該異常轉換成另一種異常。大多數情況下，這是指把一個低級的異常轉換成應用級的異常(其含義更容易被用戶了解的異常)。

　　4、不要捕獲異常。

　　結論一：既然捕獲了異常，就要對它進行適當的處理。不要捕獲異常之后又把它丟棄，不予理睬。

　　反例之二：不指定具體的異常

　　代碼：15行。

　　許多時候人們會被這樣一種“美妙的”想法吸引：用一個catch語句捕獲所有的異常。最常見的情形就是使用catch(Exceptionex)語句。但實際上，在絕大多數情況下，這種做法不值得提倡。為什么呢？

　　要理解其原因，我們必須回顧一下catch語句的用途。catch語句表示我們預期會出現某種異常，而且希望能夠處理該異常。異常類的作用就是告訴Java編譯器我們想要處理的是哪一種異常。由于絕大多數異常都直接或間接從java.lang.Exception派生，catch(Exceptionex)就相當于說我們想要處理幾乎所有的異常。

　　再來看看前面的代碼例子。我們真正想要捕獲的異常是什么呢？最明顯的一個是SQLException，這是JDBC操作中常見的異常。另一個可能的異常是IOException，因為它要操作OutputStreamWriter.顯然，在同一個catch塊中處理這兩種截然不同的異常是不合適的。如果用兩個catch塊分別捕獲SQLException和IOException就要好多了。這就是說，catch語句應當盡量指定具體的異常類型，而不應該指定涵蓋范圍太廣的Exception類。

　　另一方面，除了這兩個特定的異常，還有其他許多異常也可能出現。例如，如果由于某種原因，executeQuery返回了null，該怎么辦？答案是讓它們繼續拋出，即不必捕獲也不必處理。實際上，我們不能也不應該去捕獲可能出現的所有異常，程序的其他地方還有捕獲異常的機會？？直至最后由 JVM處理。

　　結論二：在catch語句中盡可能指定具體的異常類型，必要時使用多個catch.不要試圖處理所有可能出現的異常。

　　反例之三：占用資源不釋放

　　代碼：3行-14行。

　　異常改變了程序正常的執行流程。這個道理雖然簡單，卻常常被人們忽視。如果程序用到了文件、Socket、JDBC連接之類的資源，即使遇到了異常，也要正確釋放占用的資源。為此，Java提供了一個簡化這類操作的關鍵詞finally.

　　finally是樣好東西：不管是否出現了異常，Finally保證在try/catch/finally塊結束之前，執行清理任務的代碼總是有機會執行。遺憾的是有些人卻不習慣使用finally.

　　當然，編寫finally塊應當多加小心，特別是要注意在finally塊之內拋出的異常？？這是執行清理任務的最后機會，盡量不要再有難以處理的錯誤。

　　結論三：保證所有資源都被正確釋放。充分運用finally關鍵詞。

　　反例之四：不說明異常的詳細信息

　　代碼：3行-18行。

　　仔細觀察這段代碼：如果循環內部出現了異常，會發生什么事情？我們可以得到足夠的信息判斷循環內部出錯的原因嗎？不能。我們只能知道當前正在處理的類發生了某種錯誤，但卻不能獲得任何信息判斷導致當前錯誤的原因。

　　printStackTrace的堆棧跟蹤功能顯示出程序運行到當前類的執行流程，但只提供了一些最基本的信息，未能說明實際導致錯誤的原因，同時也不易解讀。

　　因此，在出現異常時，最好能夠提供一些文字信息，例如當前正在執行的類、方法和其他狀態信息，包括以一種更適合閱讀的方式整理和組織printStackTrace提供的信息。

　　結論四：在異常處理模塊中提供適量的錯誤原因信息，組織錯誤信息使其易于理解和閱讀。

　　反例之五：過于龐大的try塊

　　代碼：3行-14行。

　　經常可以看到有人把大量的代碼放入單個try塊，實際上這不是好習慣。這種現象之所以常見，原因就在于有些人圖省事，不愿花時間分析一大塊代碼中哪幾行代碼會拋出異常、異常的具體類型是什么。把大量的語句裝入單個巨大的try塊就象是出門旅游時把所有日常用品塞入一個大箱子，雖然東西是帶上了，但要找出來可不容易。

　　一些新手常常把大量的代碼放入單個try塊，然后再在catch語句中聲明Exception，而不是分離各個可能出現異常的段落并分別捕獲其異常。這種做法為分析程序拋出異常的原因帶來了困難，因為一大段代碼中有太多的地方可能拋出Exception.

　　結論五：盡量減小try塊的體積。

　　反例之六：輸出數據不完整

　　代碼：7行-11行。

　　不完整的數據是Java程序的隱形殺手。仔細觀察這段代碼，考慮一下如果循環的中間拋出了異常，會發生什么事情。循環的執行當然是要被打斷的，其次，catch塊會執行？？就這些，再也沒有其他動作了。已經輸出的數據怎么辦？使用這些數據的人或設備將收到一份不完整的(因而也是錯誤的)數據，卻得不到任何有關這份數據是否完整的提示。對于有些系統來說，數據不完整可能比系統停止運行帶來更大的損失。

　　較為理想的處置辦法是向輸出設備寫一些信息，聲明數據的不完整性;另一種可能有效的辦法是，先緩沖要輸出的數據，準備好全部數據之后再一次性輸出。

　　結論六：全面考慮可能出現的異常以及這些異常對執行流程的影響。

　　改寫后的代碼

　　根據上面的討論，下面給出改寫后的代碼。也許有人會說它稍微有點？嗦，但是它有了比較完備的異常處理機制。

　　OutputStreamWriter out = ...

　　java.sql.Connection conn = ...

　　try {

　　Statement stat = conn.createStatement();

　　ResultSet rs = stat.executeQuery(

　　"select uid, name from user");

　　while (rs.next())

　　{

　　out.println("ID：" + rs.getString("uid") + "，姓名: " + rs.getString("name"));

　　}

　　catch(SQLException sqlex)

　　{

　　out.println("警告：數據不完整");

　　throw new ApplicationException("讀取數據時出現SQL錯誤", sqlex);

　　}

　　catch(IOException ioex)

　　{

　　throw new ApplicationException("寫入數據時出現IO錯誤", ioex);

　　}

　　finally

　　{

　　if (conn != null) {

　　try {

　　conn.close();

　　}

　　catch(SQLException sqlex2)

　　{

　　System.err(this.getClass().getName() + ".mymethod - 不能關閉數據庫連接: " + sqlex2.toString());

　　}

　　if (out != null) {

　　try {

　　out.close();

　　}

　　catch(IOException ioex2)

　　{

　　System.err(this.getClass().getName() + ".mymethod - 不能關閉輸出文件" + ioex2.toString());

　　}

　　本文的結論不是放之四海皆準的教條，有時常識和經驗才是最好的老師。如果你對自己的做法沒有百分之百的信心，務必加上詳細、全面的注釋。

　　另一方面，不要笑話這些錯誤，不妨問問你自己是否真地徹底擺脫了這些壞習慣。即使最有經驗的程序員偶爾也會誤入歧途，原因很簡單，因為它們確確實實帶來了“方便”。所有這些反例都可以看作Java編程世界的惡魔，它們美麗動人，無孔不入，時刻誘惑著你。也許有人會認為這些都屬于雞皮蒜毛的小事，不足掛齒，但請記住：勿以惡小而為之，勿以善小而不為。

posted @ 2012-07-16 22:20 zhanghu198901 閱讀(1771) | 評論 (1) | 編輯收藏

Hibernate對象映射關系----繼承映射

單表繼承映射

每棵類繼承樹使用一個表。

映射文件Extends.hbm.xml。

<hibernate-mapping package="com.snail.hibernate">
    <class name="Animal" table="t_animal" lazy="false">
        <id name="id">
            <generator class="native"/>
        </id>
        <discriminator column="type" type="string"/>
        <property name="name"/>
        <property name="sex"/>
        <subclass name="Pig" discriminator-value="P">
             <property name="weight"/>
        </subclass>
        <subclass name="Brid" discriminator-value="B">
            <property name="height"/>
        </subclass>
    </class>
</hibernate-mapping>

因為類繼承樹肯定是對應多個類，要把多個類的信息存放在一張表中，必須有某種機制來區分哪些記錄是屬于哪個類的。這種機制就是，在表中添加一個字段，用這個字段的值來進行區分。用hibernate實現這種策略的時候，有如下步驟：

（一）父類用普通的<class>標簽定義

（二）在父類中定義一個discriminator，即指定這個區分的字段的名稱和類型

如：<discriminator column=”XXX” type=”string”/>

（三）子類使用<subclass>標簽定義，在定義subclass的時候，需要注意如下幾點：

1.Subclass標簽的name屬性是子類的全路徑名；

2.在Subclass標簽中，用discriminator-value屬性來標明本子類的discriminator字段（用來區分不同類的字段）的值；

3.Subclass標簽，既可以被class標簽所包含（這種包含關系正是表明了類之間的繼承關系），也可以與class標簽平行。當subclass標簽的定義與class標簽平行的時候，需要在subclass標簽中，添加extends屬性，里面的值是父類的全路徑名稱。

4.子類的其它屬性，像普通類一樣，定義在subclass標簽的內部。

具體表繼承映射

每個具體類一張表。（同上例）

映射文件Extends.hbm.xml。

<hibernate-mapping package="com.snail.hibernate">
    <class name="Animal" table="t_animal" lazy="false" abstract="true">
        <id name="id">
            <generator class="assigned"/>
        </id>
        <property name="name"/>
        <property name="sex"/>
        <union-subclass name="Pig" table="t_pig">
            <property name="weight"/>
        </union-subclass>
        <union-subclass name="Brid" table="t_brid">
            <property name="height"/>
        </union-subclass>
    </class>
</hibernate-mapping>

這種策略是使用union-subclass標簽來定義子類的。每個子類對應一張表，而且這個表的信息是完備的，即包含了所有從父類繼承下來的屬性映射的字段（這就是它跟joined-subclass的不同之處，joined-subclass定義的子類的表，只包含子類特有屬性映射的字段）。實現這種策略的時候，有如下步驟：

（一）父類用普通<class>標簽定義即可；

（二）子類用<union-subclass>標簽定義，在定義union-subclass的時候，需要注意如下幾點：

1.Union-subclass標簽不再需要包含key標簽（與joined-subclass不同）。

2.Union-subclass標簽，既可以被class標簽所包含（這種包含關系正是表明了類之間的繼承關系），也可以與class標簽平行。當Union-subclass標簽的定義與class標簽平行的時候，需要在Union-subclass標簽中，添加extends屬性，里面的值是父類的全路徑名稱。

3.子類的其它屬性，像普通類一樣，定義在Union-subclass標簽的內部。這個時候，雖然在union-subclass里面定義的只有子類的屬性，但是因為它繼承了父類，所以，不需要定義其它的屬性，在映射到數據庫表的時候，依然包含了父類的所有屬性的映射字段。

注意：在保存對象的時候id不能重復（不能使用數據庫的自增方式生成主鍵）

類表繼承映射

每個類一張表。（同上例）

映射文件Extends.hbm.xml。

[html] view plain copy

<hibernate-mapping package="com.snail.hibernate">
<class name="Animal" table="t_animal" lazy="false">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="sex"/>
<joined-subclass name="Pig" table="t_pig">
<key column="pid"/>
<property name="weight"/>
</joined-subclass>
<joined-subclass name="Brid" table="t_brid">
<key column="bid"/>
<property name="height"/>
</joined-subclass>
</class>
</hibernate-mapping>

這種策略是使用joined-subclass標簽來定義子類的。父類、子類，每個類都對應一張數據庫表。在父類對應的數據庫表中，實際上會存儲所有的記錄，包括父類和子類的記錄；在子類對應的數據庫表中，這個表只定義了子類中所特有的屬性映射的字段。子類與父類，通過相同的主鍵值來關聯。實現這種策略的時候，有如下步驟：

（一）父類用普通的<class>標簽定義即可，父類不再需要定義discriminator字段；

（二）子類用<joined-subclass>標簽定義，在定義joined-subclass的時候，需要注意如下幾點：

1.Joined-subclass標簽的name屬性是子類的全路徑名

2．Joined-subclass標簽需要包含一個key標簽，這個標簽指定了子類和父類之間是通過哪個字段來關聯的。

如：<key column=”PARENT_KEY_ID”/>，這里的column，實際上就是父類的主鍵對應的映射字段名稱。

3.Joined-subclass標簽，既可以被class標簽所包含（這種包含關系正是表明了類之間的繼承關系），也可以與class標簽平行。當Joined-subclass標簽的定義與class標簽平行的時候，需要在Joined-subclass標簽中，添加extends屬性，里面的值是父類的全路徑名稱。

4.子類的其它屬性，像普通類一樣，定義在joined-subclass標簽的內部。

posted @ 2012-07-16 22:16 zhanghu198901 閱讀(998) | 評論 (0) | 編輯收藏

js把毫秒轉換為 xx小時xx分鐘xx秒的通用方法

posted @ 2012-07-12 22:30 zhanghu198901 閱讀(2747) | 評論 (1) | 編輯收藏

Eclipse字符集設置方式

1、windows->Preferences...打開"首選項"對話框，左側導航樹，導航到general->Workspace，右側Text file encoding，選擇Other，改變為 utf-8(必須小寫)，以后新建立工程其屬性對話框中的Text file encoding即為UTF-8。

2、windows->Preferences...打開"首選項"對話框，左側導航樹，導航到general->Content Types，右側Content Types樹，點開Text，選擇 Java Source File，在下面的Default encoding輸入框中輸入UTF-8，點Update，則設置Java文件編碼為UTF-8。然后設置jsp、js、css等類型的Default encoding，設置方式同Java Source File。

3.windows->Preferences...打開"首選項"對話框，左側導航樹，導航到MyEclipse->Files and Editors->JSP,把Encoding改為UTF-8

posted @ 2012-07-12 22:30 zhanghu198901 閱讀(6146) | 評論 (0) | 編輯收藏

Java的API你掌握程度去到哪呢，又需要掌握到哪呢

1、java.lang包下的80％以上的類的功能的靈活運用。

2、java.util包下的80％以上的類的靈活運用，特別是集合類體系、正規表達式、時間、屬性、和Timer.

3、java.io包下的60％以上的類的使用，理解IO體系的基于管道模型的設計思路以及常用IO類的特性和使用場合。

4、java.math包下的100％的內容。

5、java.net包下的60％以上的內容，對各個類的功能比較熟悉。

6、java.text包下的60％以上的內容，特別是各種格式化類。

7、熟練運用JDBC.

8、java.security包下40％以上的內容，如果對于安全沒有接觸的話根本就不可能掌握java.

9、AWT的基本內容，包括各種組件事件、監聽器、布局管理器、常用組件、打印。

10、Swing的基本內容，和AWT的要求類似。

11、XML處理，熟悉SAX、DOM以及JDOM的優缺點并且能夠使用其中的一種完成XML的解析及內容處理。

posted @ 2012-07-12 22:30 zhanghu198901 閱讀(1110) | 評論 (2) | 編輯收藏

淺談SQL中的where 1=1 作用

where 1=1
最近看到很多sql里用到where 1=1，原來覺得這沒用嘛，但是又想到如果沒用為什么要寫呢？于是在網上

查了查，在這里就淺談一下：
1=1 永真， 1<>1 永假。

1<>1 的用處：
用于只取結構不取數據的場合
例如：
create table table_temp tablespace tbs_temp as
select * from table_ori where 1<>1
建成一個與table_ori 結構相同的表table_temp，但是不要table_ori 里的數據。（除了表結構，其它結

構也同理)

1=1的用處
用于動態SQL
例如 lv_string := 'select tbl_name,tbl_desc from tbl_test where 1=1 '||l_condition;
當用戶選擇了查詢的名稱'abc'時l_condition :='and tbl_name = ''abc'''';但是當用戶沒有

選擇名稱查詢時l_condition就為空這樣 lv_string = 'select tbl_name,tbl_desc from tbl_test

where 1=1 ' ，運行也不會出錯，相當于沒有限制名稱條件。但是如果沒有1=1的條件，則lv_string =

'select tbl_name,tbl_desc from tbl_test where ';這樣就會報錯。

除了1=1 或1<>1之外的其它永真永假的條件同理。

posted @ 2012-07-12 22:29 zhanghu198901 閱讀(966) | 評論 (0) | 編輯收藏

淺談Java對象的強、軟、弱和虛引用

在JDK1.2以前的版本中，當一個對象不被任何變量引用，那么程序就無法再使用這個對象。也就是說，只有對象處于可觸及狀態，程序才能使用它。這就像在日常生活中，從商店購買了某樣物品后，如果有用，就一直保留它，否則就把它扔到垃圾箱，由清潔工人收走。一般說來，如果物品已經被扔到垃圾箱，想再把它撿回來使用就不可能了。

但有時候情況并不這么簡單，你可能會遇到類似雞肋一樣的物品，食之無味，棄之可惜。這種物品現在已經無用了，保留它會占空間，但是立刻扔掉它也不劃算，因為也許將來還會派用場。對于這樣的可有可無的物品，一種折衷的處理辦法是：如果家里空間足夠，就先把它保留在家里，如果家里空間不夠，即使把家里所有的垃圾清除，還是無法容納那些必不可少的生活用品，那么再扔掉這些可有可無的物品。從JDK1.2版本開始，把對象的引用分為四種級別，從而使程序能更加靈活的控制對象的生命周期。這四種級別由高到低依次為：強引用、軟引用、弱引用和虛引用。

1．強引用

　　本章前文介紹的引用實際上都是強引用，這是使用最普遍的引用。如果一個對象具有強引用，那就類似于必不可少的生活用品，垃圾回收器絕不會回收它。當內存空間不足，Java虛擬機寧愿拋出OutOfMemoryError錯誤，使程序異常終止，也不會靠隨意回收具有強引用的對象來解決內存不足問題。

2．軟引用（SoftReference）

　　如果一個對象只具有軟引用，那就類似于可有可物的生活用品。如果內存空間足夠，垃圾回收器就不會回收它，如果內存空間不足了，就會回收這些對象的內存。只要垃圾回收器沒有回收它，該對象就可以被程序使用。軟引用可用來實現內存敏感的高速緩存。軟引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果軟引用所引用的對象被垃圾回收，Java虛擬機就會把這個軟引用加入到與之關聯的引用隊列中。

3．弱引用（WeakReference）

　　如果一個對象只具有弱引用，那就類似于可有可物的生活用品。弱引用與軟引用的區別在于：只具有弱引用的對象擁有更短暫的生命周期。在垃圾回收器線程掃描它所管轄的內存區域的過程中，一旦發現了只具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存。不過，由于垃圾回收器是一個優先級很低的線程，因此不一定會很快發現那些只具有弱引用的對象。弱引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果弱引用所引用的對象被垃圾回收，Java虛擬機就會把這個弱引用加入到與之關聯的引用隊列中。

4．虛引用（PhantomReference）

　　"虛引用"顧名思義，就是形同虛設，與其他幾種引用都不同，虛引用并不會決定對象的生命周期。如果一個對象僅持有虛引用，那么它就和沒有任何引用一樣，在任何時候都可能被垃圾回收。虛引用主要用來跟蹤對象被垃圾回收的活動。虛引用與軟引用和弱引用的一個區別在于：虛引用必須和引用隊列（ReferenceQueue）聯合使用。當垃圾回收器準備回收一個對象時，如果發現它還有虛引用，就會在回收對象的內存之前，把這個虛引用加入到與之關聯的引用隊列中。程序可以通過判斷引用隊列中是否已經加入了虛引用，來了解被引用的對象是否將要被垃圾回收。

posted @ 2012-07-12 22:28 zhanghu198901 閱讀(813) | 評論 (0) | 編輯收藏

APNS 是什么?

如何在 Android 應用中使用 Notification ？

spring 的三種注入方式

關于 getter 和 setter 方式的注入

詳細解析注入方式

三種注入方式比較

總結

常用鏈接

留言簿

隨筆檔案

搜索

最新評論

閱讀排行榜

評論排行榜