一個程序員多年的收藏

時間 2020-05-15

原文原文鏈接

文章分類:Java編程

09:16
瀏覽 (25526)
評論 (153)
分類: Java
收藏

2010 - 01 - 14

縮略顯示

[置頂] 一個程序員的多年珍藏(python)

文章分類:Python編程

12:07
瀏覽 (6689)
評論 (26)
分類: Java
收藏

2010 - 01 - 05

縮略顯示

一、HTML靜態化其實你們都知道，效率最高、消耗最小的就是純靜態化的html頁面，因此咱們儘量使咱們的網站上的頁面採用靜態頁面來實現，這個最簡單的方法其實也是最有效的方法。可是對於大量內容而且頻繁更新的網站，咱們沒法所有手動去挨個實現，因而出現了咱們常見的信息發佈系統CMS，像咱們常訪問的各個門戶站點的新聞頻道，甚至他們的其餘頻道，都是經過信息發佈系統來管理和實現的，信息發佈系統能夠實現最簡單的信息錄入自動生成靜態頁面，還能具有頻道管理、權限管理、自動抓取等功能，對於一個大型網站來講，擁有一套高效、可管理的CMS是必不可少的。除了門戶和信息發佈類型的網站，對於交互性要求很高的社區類型網站來講，儘量的靜態化也是提升性能的必要手段，將社區內的帖子、文章進行實時的靜態化，有更新的時候再從新靜態化也是大量使用的策略，像Mop的大雜燴就是使用了這樣的策略，網易社區等也是如此。同時，html靜態化也是某些緩存策略使用的手段，對於系統中頻繁使用數據庫查詢可是內容更新很小的應用，能夠考慮使用html靜態化來實現，好比論壇中論壇的公用設置信息，這些信息目前的主流論壇均可以進行後臺管理而且存儲再數據庫中，這些信息其實大量被前臺程序調用，可是更新頻率很小，能夠考慮將這部份內容進行後臺更新的時候進行靜態化，這樣避免了大量的數據庫訪問請求。
二、圖片服務器分離你們知道，對於Web服務器來講，無論是Apache、IIS仍是其餘容器，圖片是最消耗資源的，因而咱們有必要將圖片與頁面進行分離，這是基本上大型網站都會採用的策略，他們都有獨立的圖片服務器，甚至不少臺圖片服務器。這樣的架構能夠下降提供頁面訪問請求的服務器系統壓力，而且能夠保證系統不會由於圖片問題而崩潰，在應用服務器和圖片服務器上，能夠進行不一樣的配置優化，好比apache在配置ContentType的時候能夠儘可能少支持，儘量少的LoadModule，保證更高的系統消耗和執行效率。

三、數據庫集羣和庫表散列大型網站都有複雜的應用，這些應用必須使用數據庫，那麼在面對大量訪問的時候，數據庫的瓶頸很快就能顯現出來，這時一臺數據庫將很快沒法知足應用，因而咱們須要使用數據庫集羣或者庫表散列。在數據庫集羣方面，不少數據庫都有本身的解決方案，Oracle、Sybase等都有很好的方案，經常使用的MySQL提供的Master/Slave也是相似的方案，您使用了什麼樣的DB，就參考相應的解決方案來實施便可。上面提到的數據庫集羣因爲在架構、成本、擴張性方面都會受到所採用DB類型的限制，因而咱們須要從應用程序的角度來考慮改善系統架構，庫表散列是經常使用而且最有效的解決方案。咱們在應用程序中安裝業務和應用或者功能模塊將數據庫進行分離，不一樣的模塊對應不一樣的數據庫或者表，再按照必定的策略對某個頁面或者功能進行更小的數據庫散列，好比用戶表，按照用戶ID進行表散列，這樣就可以低成本的提高系統的性能而且有很好的擴展性。sohu的論壇就是採用了這樣的架構，將論壇的用戶、設置、帖子等信息進行數據庫分離，而後對帖子、用戶按照板塊和ID進行散列數據庫和表，最終能夠在配置文件中進行簡單的配置便能讓系統隨時增長一臺低成本的數據庫進來補充系統性能。

四、緩存緩存一詞搞技術的都接觸過，不少地方用到緩存。網站架構和網站開發中的緩存也是很是重要。這裏先講述最基本的兩種緩存。高級和分佈式的緩存在後面講述。架構方面的緩存，對Apache比較熟悉的人都能知道Apache提供了本身的緩存模塊，也能夠使用外加的Squid模塊進行緩存，這兩種方式都可以有效的提升Apache的訪問響應能力。網站程序開發方面的緩存，Linux上提供的Memory Cache是經常使用的緩存接口，能夠在web開發中使用，好比用Java開發的時候就能夠調用MemoryCache對一些數據進行緩存和通信共享，一些大型社區使用了這樣的架構。另外，在使用web語言開發的時候，各類語言基本都有本身的緩存模塊和方法，PHP有Pear的Cache模塊，Java就更多了，.net不是很熟悉，相信也確定有。

五、鏡像鏡像是大型網站常採用的提升性能和數據安全性的方式，鏡像的技術能夠解決不一樣網絡接入商和地域帶來的用戶訪問速度差別，好比 ChinaNet和EduNet之間的差別就促使了不少網站在教育網內搭建鏡像站點，數據進行定時更新或者實時更新。在鏡像的細節技術方面，這裏不闡述太深，有不少專業的現成的解決架構和產品可選。也有廉價的經過軟件實現的思路，好比Linux上的rsync等工具。
六、負載均衡負載均衡將是大型網站解決高負荷訪問和大量併發請求採用的終極解決辦法。負載均衡技術發展了多年，有不少專業的服務提供商和產品能夠選擇，我我的接觸過一些解決方法，其中有兩個架構能夠給你們作參考。

七、硬件四層交換第四層交換使用第三層和第四層信息包的報頭信息，根據應用區間識別業務流，將整個區間段的業務流分配到合適的應用服務器進行處理。　第四層交換功能就象是虛 IP，指向物理服務器。它傳輸的業務服從的協議多種多樣，有HTTP、FTP、NFS、Telnet或其餘協議。這些業務在物理服務器基礎上，須要複雜的載量平衡算法。在IP世界，業務類型由終端TCP或UDP端口地址來決定，在第四層交換中的應用區間則由源端和終端IP地址、TCP和UDP端口共同決定。在硬件四層交換產品領域，有一些知名的產品能夠選擇，好比Alteon、F5等，這些產品很昂貴，可是物有所值，可以提供很是優秀的性能和很靈活的管理能力。Yahoo中國當初接近2000臺服務器使用了三四臺Alteon就搞定了

。八、軟件四層交換你們知道了硬件四層交換機的原理後，基於OSI模型來實現的軟件四層交換也就應運而生，這樣的解決方案實現的原理一致，不過性能稍差。可是知足必定量的壓力仍是遊刃有餘的，有人說軟件實現方式其實更靈活，處理能力徹底看你配置的熟悉能力。軟件四層交換咱們能夠使用Linux上經常使用的LVS來解決，LVS就是Linux Virtual Server，他提供了基於心跳線heartbeat的實時災難應對解決方案，提升系統的魯棒性，同時可供了靈活的虛擬VIP配置和管理功能，能夠同時知足多種應用需求，這對於分佈式的系統來講必不可少。一個典型的使用負載均衡的策略就是，在軟件或者硬件四層交換的基礎上搭建squid集羣，這種思路在不少大型網站包括搜索引擎上被採用，這樣的架構低成本、高性能還有很強的擴張性，隨時往架構裏面增減節點都很是容易。這樣的架構我準備空了專門詳細整理一下和你們探討。對於大型網站來講，前面提到的每一個方法可能都會被同時使用到，我這裏介紹得比較淺顯，具體實現過程當中不少細節還須要你們慢慢熟悉和體會，有時一個很小的squid參數或者apache參數設置，對於系統性能的影響就會很大，但願你們一塊兒討論，達到拋磚引玉之效。

用squid作web cache server，而apache在squid的後面提供真正的web服務。固然使用這樣的架構必需要保證主頁上大部分都是靜態頁面。這就須要程序員的配合將頁面在反饋給客戶端以前將頁面所有轉換成靜態頁面。
基本看出sina和sohu對於頻道等欄目都用了相同的技術，即squid來監聽這些IP的80端口，而真正的web server來監聽另一個端口。從用戶的感受上來講不會有任何的區別，而相對於將web server直接和客戶端連在一塊兒的方式，這樣的方式明顯的節省的帶寬和服務器。用戶訪問的速度感受也會更快。
http://www.dbanotes.net/arch/yupoo_arch.html

帶寬：4000M/S (參考)
服務器數量：60 臺左右
Web服務器：Lighttpd, Apache, nginx
應用服務器：Tomcat
其餘：Python, Java, MogileFS 、ImageMagick 等

關於 Squid 與 Tomcat

Squid 與 Tomcat 彷佛在 Web 2.0 站點的架構中較少看到。我首先是對 Squid 有點疑問，對此阿華的解釋是"目前暫時還沒找到效率比 Squid 高的緩存系統，原來命中率的確不好，後來在 Squid 前又裝了層 Lighttpd, 基於 url 作 hash, 同一個圖片始終會到同一臺 squid 去，因此命中率完全提升了"

對於應用服務器層的 Tomcat，如今 Yupoo! 技術人員也在逐漸用其餘輕量級的東西替代，而 YPWS/YPFS 如今已經用 Python 進行開發了。

名次解釋：

· YPWS--Yupoo Web Server YPWS 是用 Python開發的一個小型 Web 服務器，提供基本的 Web 服務外，能夠增長針對用戶、圖片、外鏈網站顯示的邏輯判斷，能夠安裝於任何有空閒資源的服務器中，遇到性能瓶頸時方便橫向擴展。

· YPFS--Yupoo File System 與 YPWS 相似，YPFS 也是基於這個 Web 服務器上開發的圖片上傳服務器。

【Updated: 有網友留言質疑 Python 的效率，Yupoo 老大劉平陽在 del.icio.us 上寫到 "YPWS用Python本身寫的，每臺機器每秒能夠處理294個請求, 如今壓力幾乎都在10％如下"】

圖片處理層

接下來的 Image Process Server 負責處理用戶上傳的圖片。使用的軟件包也是 ImageMagick，在上次存儲升級的同時，對於銳化的比率也調整過了(我我的感受，效果的確好了不少)。」Magickd「是圖像處理的一個遠程接口服務，能夠安裝在任何有空閒 CPU資源的機器上，相似 Memcached的服務方式。

咱們知道 Flickr 的縮略圖功能原來是用 ImageMagick 軟件包的，後來被雅虎收購後出於版權緣由而不用了（?）；EXIF 與 IPTC Flicke 是用 Perl 抽取的，我是很是建議 Yupoo! 針對 EXIF 作些文章，這也是潛在產生受益的一個重點。

圖片存儲層

原來 Yupoo! 的存儲採用了磁盤陣列櫃，基於 NFS 方式的，隨着數據量的增大，」Yupoo! 開發部從07年6月份就開始着手研究一套大容量的、能知足 Yupoo! 從此發展須要的、安全可靠的存儲系統「，看來 Yupoo! 系統比較有信心，也是滿懷期待的，畢竟這要支撐以 TB 計算的海量圖片的存儲和管理。咱們知道，一張圖片除了原圖外，還有不一樣尺寸的，這些圖片統一存儲在 MogileFS 中。

對於其餘部分，常見的 Web 2.0 網站必須軟件都能看到，如 MySQL、Memcached 、Lighttpd 等。Yupoo! 一方面採用很多相對比較成熟的開源軟件，一方面也在自行開發定製適合本身的架構組件。這也是一個 Web 2.0 公司所必須要走的一個途徑。

很是感謝一下 Yupoo! 阿華對於技術信息的分享，技術是共通的。下一個能爆料是哪家?

--EOF--

lighttpd+squid這套緩存是放在另一個機房做爲cdn的一個節點使用的，圖中沒描繪清楚，給你們帶來不便了。
squid前端用lighttpd沒用nginx，主要是用了這麼久，沒出啥大問題，因此就沒想其餘的了。
URL Hash的擴展性的確很差，能作的就是不輕易去增減服務器，咱們目前是5臺服務器作一組hash.

咱們如今用Python寫的Web Server，在效率方面，我能夠給個測試數據，根據目前的訪問日誌模擬訪問測試的結果是1臺ypws,平均每秒處理294個請求(加載全部的邏輯判斷)。
在可靠性上，還不沒具體的數據，目前運行1個多月尚未任何異常。

lvs每一個節點上都裝nginx，主要是爲了反向代理及處理靜態內容，不過apache已顯得不是那麼必需，準備逐漸去掉。

咱們處理圖片都是即時的，咱們目前半數以上的服務器都裝了magickd服務，用來分擔圖片處理請求。

http://www.dbanotes.net/review/tailrank_arch.html

天天數以千萬計的 Blog 內容中，實時的熱點是什麼? Tailrank 這個 Web 2.0 Startup 致力於回答這個問題。

專門爆料網站架構的 Todd Hoff 對 Kevin Burton 進行了採訪。因而咱們能瞭解一下 Tailrank 架構的一些信息。每小時索引 2400 萬的 Blog 與 Feed，內容處理能力爲 160-200Mbps，IO 寫入大約在10-15MBps。每月要處理 52T 之多的原始數據。Tailrank 所用的爬蟲如今已經成爲一個獨立產品：spinn3r。

服務器硬件

目前大約 15 臺服務器，CPU 是 64 位的 Opteron。每臺主機上掛兩個 SATA 盤，作 RAID 0。據我所知，國內不少 Web 2.0 公司也用的是相似的方式，SATA 盤容量達，低廉價格，堪稱不二之選。操做系統用的是 Debian Linux 。Web 服務器用 Apache 2.0，Squid 作反向代理服務器。

數據庫

Tailrank 用 MySQL 數據庫，聯邦數據庫形式。存儲引擎用 InnoDB，數據量 500GB。Kevin Burton 也指出了 MySQL 5 在修了一些多核模式下互斥鎖的問題(This Bug?)。到數據庫的JDBC 驅動鏈接池用 lbpool 作負載均衡。MySQL Slave 或者 Master的複製用 MySQLSlaveSync 來輕鬆完成。不過即便這樣，還要花費 20％的時間來折騰 DB。

其餘開放的軟件

任何一套系統都離不開合適的 Profiling 工具，Tailrank 也不利外，針對 Java 程序的 Benchmark 用 Benchmark4j。Log 工具用 Log5j(不是 Log4j)。Tailrank 所用的大部分工具都是開放的。

Tailrank 的一個比較大的競爭對手是 Techmeme，雖然兩者暫時看面向內容的側重點有所不一樣。其實，最大的對手仍是本身，當須要挖掘的信息量愈來愈大，若是精準並及時的呈現給用戶內容的成本會愈來愈高。從如今來看，Tailrank 離預期目標還差的很遠。期待羅馬早日建成

YouTube架構學習

關鍵字: YouTube

原文: YouTube Architecture

YouTube發展迅速，天天超過1億的視頻點擊量，但只有不多人在維護站點和確保伸縮性。

平臺
Apache
Python
Linux(SuSe)
MySQL
psyco，一個動態的Python到C的編譯器
lighttpd代替Apache作視頻查看

狀態
支持天天超過1億的視頻點擊量
成立於2005年2月
於2006年3月達到天天3千萬的視頻點擊量
於2006年7月達到天天1億的視頻點擊量
2個系統管理員，2個伸縮性軟件架構師
2個軟件開發工程師，2個網絡工程師，1個DBA

處理飛速增加的流量

Java代碼

1. while (true)

2. {

3. identify_and_fix_bottlenecks();

4. drink();

5. sleep();

6. notice_new_bottleneck();

7. }

while (true)

{

identify_and_fix_bottlenecks();

drink();

sleep();

notice_new_bottleneck();

}

天天運行該循環屢次

Web服務器
1，NetScaler用於負載均衡和靜態內容緩存
2，使用mod_fast_cgi運行Apache
3，使用一個Python應用服務器來處理請求的路由
4，應用服務器與多個數據庫和其餘信息源交互來獲取數據和格式化html頁面
5，通常能夠經過添加更多的機器來在Web層提升伸縮性
6，Python的Web層代碼一般不是性能瓶頸，大部分時間阻塞在RPC
7，Python容許快速而靈活的開發和部署
8，一般每一個頁面服務少於100毫秒的時間
9，使用psyco(一個相似於JIT編譯器的動態的Python到C的編譯器)來優化內部循環
10，對於像加密等密集型CPU活動，使用C擴展
11，對於一些開銷昂貴的塊使用預先生成並緩存的html
12，數據庫裏使用行級緩存
13，緩存完整的Python對象
14，有些數據被計算出來併發送給各個程序，因此這些值緩存在本地內存中。這是個使用不當的策略。應用服務器裏最快的緩存將預先計算的值發送給全部服務器也花不了多少時間。只需弄一個代理來監聽更改，預計算，而後發送。

視頻服務
1，花費包括帶寬，硬件和能源消耗
2，每一個視頻由一個迷你集羣來host，每一個視頻被超過一臺機器持有
3，使用一個集羣意味着：
-更多的硬盤來持有內容意味着更快的速度
-failover。若是一臺機器出故障了，另外的機器能夠繼續服務
-在線備份
4，使用lighttpd做爲Web服務器來提供視頻服務：
-Apache開銷太大
-使用epoll來等待多個fds
-從單進程配置轉變爲多進程配置來處理更多的鏈接
5，大部分流行的內容移到CDN：
-CDN在多個地方備分內容，這樣內容離用戶更近的機會就會更高
-CDN機器常常內存不足，由於內容太流行以至不多有內容進出內存的顛簸
6，不太流行的內容(天天1-20瀏覽次數)在許多colo站點使用YouTube服務器
-長尾效應。一個視頻能夠有多個播放，可是許多視頻正在播放。隨機硬盤塊被訪問
-在這種狀況下緩存不會很好，因此花錢在更多的緩存上可能沒太大意義。
-調節RAID控制並注意其餘低級問題
-調節每臺機器上的內存，不要太多也不要太少

視頻服務關鍵點
1，保持簡單和廉價
2，保持簡單網絡路徑，在內容和用戶間不要有太多設備
3，使用經常使用硬件，昂貴的硬件很難找到幫助文檔
4，使用簡單而常見的工具，使用構建在Linux裏或之上的大部分工具
5，很好的處理隨機查找(SATA，tweaks)

縮略圖服務
1，作到高效使人驚奇的難
2，每一個視頻大概4張縮略圖，因此縮略圖比視頻多不少
3，縮略圖僅僅host在幾個機器上
4，持有一些小東西所遇到的問題：
-OS級別的大量的硬盤查找和inode和頁面緩存問題
-單目錄文件限制，特別是Ext3，後來移到多分層的結構。內核2.6的最近改進可能讓Ext3容許大目錄，但在一個文件系統裏存儲大量文件不是個好主意
-每秒大量的請求，由於Web頁面可能在頁面上顯示60個縮略圖
-在這種高負載下Apache表現的很是糟糕
-在Apache前端使用squid，這種方式工做了一段時間，可是因爲負載繼續增長而以失敗了結。它讓每秒300個請求變爲20個
-嘗試使用lighttpd可是因爲使用單線程它陷於困境。遇到多進程的問題，由於它們各自保持本身單獨的緩存
-如此多的圖片以至一臺新機器只能接管24小時
-重啓機器須要6-10小時來緩存
5，爲了解決全部這些問題YouTube開始使用Google的BigTable，一個分佈式數據存儲：
-避免小文件問題，由於它將文件收集到一塊兒
-快，錯誤容忍
-更低的延遲，由於它使用分佈式多級緩存，該緩存與多個不一樣collocation站點工做
-更多信息參考Google Architecture，GoogleTalk Architecture和BigTable

數據庫
1，早期
-使用MySQL來存儲元數據，如用戶，tags和描述
-使用一整個10硬盤的RAID 10來存儲數據
-依賴於信用卡因此YouTube租用硬件
-YouTube通過一個常見的革命：單服務器，而後單master和多read slaves，而後數據庫分區，而後sharding方式
-痛苦與備份延遲。master數據庫是多線程的而且運行在一個大機器上因此它能夠處理許多工做，slaves是單線程的而且一般運行在小一些的服務器上而且備份是異步的，因此slaves會遠遠落後於master
-更新引發緩存失效，硬盤的慢I/O致使慢備份
-使用備份架構須要花費大量的money來得到增長的寫性能
-YouTube的一個解決方案是經過把數據分紅兩個集羣來將傳輸分出優先次序：一個視頻查看池和一個通常的集羣
2，後期
-數據庫分區
-分紅shards，不一樣的用戶指定到不一樣的shards
-擴散讀寫
-更好的緩存位置意味着更少的IO
-致使硬件減小30%
-備份延遲下降到0
-如今能夠任意提高數據庫的伸縮性

數據中心策略
1，依賴於信用卡，因此最初只能使用受管主機提供商
2，受管主機提供商不能提供伸縮性，不能控制硬件或使用良好的網絡協議
3，YouTube改成使用colocation arrangement。如今YouTube能夠自定義全部東西而且協定本身的契約
4，使用5到6個數據中心加CDN
5，視頻來自任意的數據中心，不是最近的匹配或其餘什麼。若是一個視頻足夠流行則移到CDN
6，依賴於視頻帶寬而不是真正的延遲。能夠來自任何colo
7，圖片延遲很嚴重，特別是當一個頁面有60張圖片時
8，使用BigTable將圖片備份到不一樣的數據中心，代碼查看誰是最近的

學到的東西
1，Stall for time。創造性和風險性的技巧讓你在短時間內解決問題而同時你會發現長期的解決方案
2，Proioritize。找出你的服務中核心的東西並對你的資源分出優先級別
3，Pick your battles。別怕將你的核心服務分出去。YouTube使用CDN來分佈它們最流行的內容。建立本身的網絡將花費太多時間和太多money
4，Keep it simple！簡單容許你更快的從新架構來回應問題
5，Shard。Sharding幫助隔離存儲，CPU，內存和IO，不只僅是得到更多的寫性能
6，Constant iteration on bottlenecks：
-軟件：DB，緩存
-OS：硬盤I/O
-硬件：內存，RAID
7，You succeed as a team。擁有一個跨越條律的瞭解整個系統並知道系統內部是什麼樣的團隊，如安裝打印機，安裝機器，安裝網絡等等的人。With a good team all things are possible。

http://hideto.javaeye.com/blog/130815

Google架構學習

關鍵字: Google

原文：Google Architecture

Google是伸縮性的王者。Google一直的目標就是構建高性能高伸縮性的基礎組織來支持它們的產品。

平臺
Linux
大量語言：Python，Java，C++

狀態
在2006年大約有450,000臺廉價服務器
在2005年Google索引了80億Web頁面，如今沒有人知道數目
目前在Google有超過200個GFS集羣。一個集羣能夠有1000或者甚至5000臺機器。成千上萬的機器從運行着5000000000000000字節存儲的GFS集羣獲取數據，集羣總的讀寫吞吐量能夠達到每秒40兆字節
目前在Google有6000個MapReduce程序，並且每月都寫成百個新程序
BigTable伸縮存儲幾十億的URL，幾百千千兆的衛星圖片和幾億用戶的參數選擇

堆棧
Google形象化它們的基礎組織爲三層架構：
1，產品：搜索，廣告，email，地圖，視頻，聊天，博客
2，分佈式系統基礎組織：GFS，MapReduce和BigTable
3，計算平臺：一羣不一樣的數據中內心的機器
4，確保公司裏的人們部署起來開銷很小
5，花費更多的錢在避免丟失日誌數據的硬件上，其餘類型的數據則花費較少

可信賴的存儲機制GFS(Google File System)
1，可信賴的伸縮性存儲是任何程序的核心需求。GFS就是Google的核心存儲平臺
2，Google File System - 大型分佈式結構化日誌文件系統，Google在裏面扔了大量的數據
3，爲何構建GFS而不是利用已有的東西？由於能夠本身控制一切而且這個平臺與別的不同，Google須要：
-跨數據中心的高可靠性
-成千上萬的網絡節點的伸縮性
-大讀寫帶寬的需求
-支持大塊的數據，可能爲上千兆字節
-高效的跨節點操做分發來減小瓶頸
4，系統有Master和Chunk服務器
-Master服務器在不一樣的數據文件裏保持元數據。數據以64MB爲單位存儲在文件系統中。客戶端與Master服務器交流來在文件上作元數據操做而且找到包含用戶須要數據的那些Chunk服務器
-Chunk服務器在硬盤上存儲實際數據。每一個Chunk服務器跨越3個不一樣的Chunk服務器備份以建立冗餘來避免服務器崩潰。一旦被Master服務器指明，客戶端程序就會直接從Chunk服務器讀取文件
6，一個上線的新程序能夠使用已有的GFS集羣或者能夠製做本身的GFS集羣
7，關鍵點在於有足夠的基礎組織來讓人們對本身的程序有所選擇，GFS能夠調整來適應個別程序的需求

使用MapReduce來處理數據
1，如今你已經有了一個很好的存儲系統，你該怎樣處理如此多的數據呢？好比你有許多TB的數據存儲在1000臺機器上。數據庫不能伸縮或者伸縮到這種級別花費極大，這就是 MapReduce出現的緣由
2， MapReduce是一個處理和生成大量數據集的編程模型和相關實現。用戶指定一個 map方法來處理一個鍵/值對來生成一箇中間的鍵/值對，還有一個reduce方法來合併全部關聯到一樣的中間鍵的中間值。許多真實世界的任務均可以使用這種模型來表現。以這種風格來寫的程序會自動並行的在一個大量機器的集羣裏運行。運行時系統照顧輸入數據劃分、程序在機器集之間執行的調度、機器失敗處理和必需的內部機器交流等細節。這容許程序員沒有多少並行和分佈式系統的經驗就能夠很容易使用一個大型分佈式系統資源
3，爲何使用 MapReduce？
-跨越大量機器分割任務的好方式
-處理機器失敗
-能夠與不一樣類型的程序工做，例如搜索和廣告。幾乎任何程序都有 map和reduce類型的操做。你能夠預先計算有用的數據、查詢字數統計、對TB的數據排序等等
4， MapReduce系統有三種不一樣類型的服務器
-Master服務器分配用戶任務到 Map和Reduce服務器。它也跟蹤任務的狀態
- Map服務器接收用戶輸入並在其基礎上處理 map操做。結果寫入中間文件
-Reduce服務器接收 Map服務器產生的中間文件並在其基礎上處理reduce操做
5，例如，你想在全部Web頁面裏的字數。你將存儲在GFS裏的全部頁面拋入 MapReduce。這將在成千上萬臺機器上同時進行而且全部的調整、工做調度、失敗處理和數據傳輸將自動完成
-步驟相似於：GFS -> Map -> Shuffle -> Reduction -> Store Results back into GFS
-在 MapReduce裏一個 map操做將一些數據映射到另外一箇中，產生一個鍵值對，在咱們的例子裏就是字和字數
-Shuffling操做彙集鍵類型
-Reduction操做計算全部鍵值對的綜合併產生最終的結果
6，Google索引操做管道有大約20個不一樣的 map和reduction。
7，程序能夠很是小，如20到50行代碼
8，一個問題是掉隊者。掉隊者是一個比其餘程序慢的計算，它阻塞了其餘程序。掉隊者可能由於緩慢的IO或者臨時的CPU不能使用而發生。解決方案是運行多個一樣的計算而且當一個完成後殺死全部其餘的
9，數據在 Map和Reduce服務器之間傳輸時被壓縮了。這能夠節省帶寬和I/O。

在BigTable裏存儲結構化數據
1，BigTable是一個大伸縮性、錯誤容忍、自管理的系統，它包含千千兆的內存和1000000000000000的存儲。它能夠每秒鐘處理百萬的讀寫
2，BigTable是一個構建於GFS之上的分佈式哈希機制。它不是關係型數據庫。它不支持join或者SQL類型查詢
3，它提供查詢機制來經過鍵訪問結構化數據。GFS存儲存儲不透明的數據而許多程序需求有結構化數據
4，商業數據庫不能達到這種級別的伸縮性而且不能在成千上萬臺機器上工做
5，經過控制它們本身的低級存儲系統Google獲得更多的控制權來改進它們的系統。例如，若是它們想讓跨數據中心的操做更簡單這個特性，它們能夠內建它
6，系統運行時機器能夠自由的增刪而整個系統保持工做
7，每一個數據條目存儲在一個格子裏，它能夠經過一個行key和列key或者時間戳來訪問
8，每一行存儲在一個或多個tablet中。一個tablet是一個64KB塊的數據序列而且格式爲SSTable
9，BigTable有三種類型的服務器：
-Master服務器分配tablet服務器，它跟蹤tablet在哪裏而且若是須要則從新分配任務
-Tablet服務器爲tablet處理讀寫請求。當tablet超過大小限制(一般是100MB-200MB)時它們拆開tablet。當一個Tablet服務器失敗時，則100個Tablet服務器各自挑選一個新的tablet而後系統恢復。
-Lock服務器造成一個分佈式鎖服務。像打開一個tablet來寫、Master調整和訪問控制檢查等都須要互斥
10，一個locality組能夠用來在物理上將相關的數據存儲在一塊兒來獲得更好的locality選擇
11，tablet儘量的緩存在RAM裏

硬件
1，當你有不少機器時你怎樣組織它們來使得使用和花費有效？
2，使用很是廉價的硬件
3，A 1,000-fold computer power increase can be had for a 33 times lower cost if you you use a failure-prone infrastructure rather than an infrastructure built on highly reliable components. You must build reliability on top of unreliability for this strategy to work.
4，Linux，in-house rack design，PC主板，低端存儲
5，Price per wattage on performance basis isn't getting better. Have huge power and cooling issues
6，使用一些collocation和Google本身的數據中心

其餘
1，迅速更改而不是等待QA
2，庫是構建程序的卓越方式
3，一些程序做爲服務提供
4，一個基礎組織處理程序的版本，這樣它們能夠發佈而不用懼怕會破壞什麼東西

Google未來的方向
1，支持地理位置分佈的集羣
2，爲全部數據建立一個單獨的全局名字空間。當前的數據由集羣分離
3，更多和更好的自動化數據遷移和計算
4，解決當使用網絡劃分來作廣闊區域的備份時的一致性問題(例如保持服務即便一個集羣離線維護或因爲一些損耗問題)

學到的東西
1，基礎組織是有競爭性的優點。特別是對Google而言。Google能夠很快很廉價的推出新服務，而且伸縮性其餘人很難達到。許多公司採起徹底不一樣的方式。許多公司認爲基礎組織開銷太大。Google認爲本身是一個系統工程公司，這是一個新的看待軟件構建的方式
2，跨越多個數據中心仍然是一個未解決的問題。大部分網站都是一個或者最多兩個數據中心。咱們不得不認可怎樣在一些數據中心之間完整的分佈網站是很須要技巧的
3，若是你本身沒有時間從零開始從新構建全部這些基礎組織你能夠看看Hadoop。Hadoop是這裏不少一樣的主意的一個開源實現
4，平臺的一個優勢是初級開發人員能夠在平臺的基礎上快速而且放心的建立健全的程序。若是每一個項目都須要發明一樣的分佈式基礎組織的輪子，那麼你將陷入困境由於知道怎樣完成這項工做的人相對較少
5，協同工做不一直是擲骰子。經過讓系統中的全部部分一塊兒工做則一個部分的改進將幫助全部的部分。改進文件系統則每一個人從中受益並且是透明的。若是每一個項目使用不一樣的文件系統則在整個堆棧中享受不到持續增長的改進
6，構建自管理系統讓你不必讓系統關機。這容許你更容易在服務器之間平衡資源、動態添加更大的容量、讓機器離線和優雅的處理升級
7，建立可進化的基礎組織，並行的執行消耗時間的操做並採起較好的方案
8，不要忽略學院。學院有許多沒有轉變爲產品的好主意。Most of what Google has done has prior art, just not prior large scale deployment.
9，考慮壓縮。當你有許多CPU而IO有限時壓縮是一個好的選擇。

http://blog.daviesliu.net/2006/09/09/010620/

Lighttpd+Squid+Apache搭建高效率Web服務器

架構原理

Apache一般是開源界的首選Web服務器，由於它的強大和可靠，已經具備了品牌效應，能夠適用於絕大部分的應用場合。可是它的強大有時候卻顯得笨重，配置文件得讓人望而生畏，高併發狀況下效率不過高。而輕量級的Web服務器Lighttpd倒是後起之秀，其靜態文件的響應能力遠高於 Apache，聽說是Apache的2-3倍。Lighttpd的高性能和易用性，足以打動咱們，在它可以勝任的領域，儘可能用它。Lighttpd對 PHP的支持也很好，還能夠經過Fastcgi方式支持其餘的語言，好比Python。

畢竟Lighttpd是輕量級的服務器，功能上不能跟Apache比，某些應用沒法勝任。好比Lighttpd還不支持緩存，而如今的絕大部分站點都是用程序生成動態內容，沒有緩存的話即便程序的效率再高也很難知足大訪問量的需求，並且讓程序不停的去作同一件事情也實在沒有意義。首先，Web程序是須要作緩存處理的，即把反覆使用的數據作緩存。即便這樣也還不夠，單單是啓動Web處理程序的代價就很多，緩存最後生成的靜態頁面是必不可少的。而作這個是 Squid的強項，它本是作代理的，支持高效的緩存，能夠用來給站點作反向代理加速。把Squid放在Apache或者Lighttpd的前端來緩存 Web服務器生成的動態內容，而Web應用程序只須要適當地設置頁面實效時間便可。

即便是大部份內容動態生成的網站，仍免不了會有一些靜態元素，好比圖片、JS腳本、CSS等等，將Squid放在Apache或者Lighttp 前端後，反而會使性能降低，畢竟處理HTTP請求是Web服務器的強項。並且已經存在於文件系統中的靜態內容再在Squid中緩存一下，浪費內存和硬盤空間。所以能夠考慮將Lighttpd再放在Squid的前面，構成 Lighttpd+Squid+Apache的一條處理鏈，Lighttpd在最前面，專門用來處理靜態內容的請求，把動態內容請求經過proxy模塊轉發給Squid，若是Squid中有該請求的內容且沒有過時，則直接返回給Lighttpd。新請求或者過時的頁面請求交由Apache中Web程序來處理。通過Lighttpd和Squid的兩級過濾，Apache須要處理的請求將大大減小，減小了Web應用程序的壓力。同時這樣的構架，便於把不一樣的處理分散到多臺計算機上進行，由Lighttpd在前面統一把關。

在這種架構下，每一級都是能夠進行單獨優化的，好比Lighttpd能夠採用異步IO方式，Squid能夠啓用內存來緩存，Apache能夠啓用MPM 等，而且每一級均可以使用多臺機器來均衡負載，伸縮性很好。

08:31
瀏覽 (798)
評論 (0)
分類: Java
收藏

2009 - 10 - 31

縮略顯示

Java基礎學習筆記

文章分類:Java編程

1.Java語言的特色：面向對象，跨平臺，多線程

2.Java運行環境：JVM+Java API

3.數據類型：
boolean 1
char 16
byte 8
short 16
int 32
long 64
float 32
double 64

4.面向對象：
封裝：類　
繼承：單一繼承　
多態：重寫(Overridding)與重載(Overloading)
在子類中，方法的參數個數和返回值都與父類相同，稱爲重寫
在同一個類中，方法的參數不一樣，稱爲重載

5.做用域：
private 子類不能繼承
default 若是不在同一包中，子類不能繼承
protected
public
　　　　　　　
6.垃圾回收原理：有向圖原則(另外一種爲計數器類型)，可能會有內存泄漏,計數器類型與有向圖類型相比：效率更高，可是精度偏低，由於它很難發現變量循環引用的問題
會有內存泄漏的代碼：
Vector v=new Vector(10)
for (int i=0;i<10;i++){
Object o=new Object();
v.add(o);
o=null;
}
解決方法：
v=null;

7.棧與堆：原始數據類型存放在棧裏，對象數據類型存放在堆中，棧中存放堆中的地址。

8.變量比較：==比較的是棧，原始數據類型相同，可是引用類型值不等，equals比較的是堆，特例是string，java.lang.String類是final類型的,所以不能夠繼承這個類、不能修改這個類。

9.變量複製：原始數據類型複製的是值，引用數據類型複製的是棧中的引用，因此當一個修改的時候，會影響另外一個。對象複製：Object.clone()方法

10.引用傳遞和值傳遞：原始數據類型傳遞的是值，引用數據類型傳遞的是棧中的引用

11.異常：(Java.lang.Exception)檢查時異常，(Java.lang.RuntimeException)運行時異常，((java.lang.Error)錯誤，檢查時異常必須處理

12.集合：collection: set:HashSet TreeSet
list:ArrayList LinkedList Vector Stack
map:Hash Map Tree Map HashTable Properties

13.Set裏的元素是不能重複的,什麼方法來區分重複與否呢? 是用==仍是
equals()? 它們有何區別?
Set裏的元素是不能重複的,那麼用iterator()方法來區分重複與否。equals()是判讀兩
個Set是否相等。
equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋,爲的是當兩個
分離的對象的內容和類型相配的話,返回真值

14.ArrayList, Vector, LinkedList的存儲性能和特性
ArrayList和Vector都是使用數組方式存儲數據,此數組元素數大於實際存儲的數據
以便增長和插入元素,它們都容許直接按序號索引元素,可是插入元素要涉及數組元
素移動等內存操做,因此索引數據快而插入數據慢,Vector因爲使用了synchronized方
法(線程安全),一般性能上較ArrayList差,而LinkedList使用雙向鏈表實現存儲,按序
號索引數據須要進行前向或後向遍歷,可是插入數據時只須要記錄本項的先後項即
可,因此插入速度較快。

1五、Hash Map和Hashtable的區別。
Hash Map是Hashtable的輕量級實現(非線程安全的實現),他們都完成了 Map接口,
主要區別在於Hash Map容許空(null)鍵值(key),因爲非線程安全,效率上可能高於
Hashtable。
Hash Map容許將null做爲一個entry的key或者value,而Hashtable不容許。
Hash Map把Hashtable的contains方法去掉了,改爲containsvalue和containsKey。由於
contains方法容易讓人引發誤解。
Hashtable繼承自Dictionary類,而Hash Map是Java1.2引進的 Map interface的一個實現。
最大的不一樣是,Hashtable的方法是Synchronize的,而Hash Map不是,在多個線程訪問
Hashtable時,不須要本身爲它的方法實現同步,而Hash Map 就必須爲之提供外同步。
Hashtable和Hash Map採用的hash/rehash算法都大概同樣,因此性能不會有很大的差別。

22:23
瀏覽 (477)
評論 (1)
分類: Java
收藏

2009 - 07 - 02

縮略顯示

定時執行任務的三種方法

定時執行任務的三種方法:

1）java.util.Timer.

2）ServletContextListener.

3）org.springframework.scheduling.timer.ScheduledTimerTask

1）java.util.Timer
這個方法應該是最經常使用的，不過這個方法須要手工啓動你的任務：
Timer timer=new Timer();
timer.schedule(new ListByDayTimerTask(),10000,86400000);
這裏的ListByDayTimerTask類必須extends TimerTask裏面的run()方法。

2）ServletContextListener
這個方法在web容器環境比較方便，這樣，在web server啓動後就能夠自動運行該任務，不須要手工操做。
將ListByDayListener implements ServletContextListener接口，在contextInitialized方法中加入啓動Timer的代碼，在 contextDestroyed方法中加入cancel該Timer的代碼；而後在web.xml中，加入listener:
<-listener>
<-listener-class>com.qq.customer.ListByDayListener</listener-class>
<-/listener>

3)org.springframework.scheduling.timer.ScheduledTimerTask若是你用spring，那麼你不須要寫Timer類了，在schedulingContext-timer.xml中加入下面的內容就能夠了：
<?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="timer" class="org.springframework.scheduling.timer.TimerFactoryBean">
<property name="scheduledTimerTasks">
<list>
<ref local="MyTimeTask1"/>
</list>
</property>
</bean>

<bean id="MyTimeTask" class="com.qq.timer.ListByDayTimerTask"/>

<bean id="MyTimeTask1" class="org.springframework.scheduling.timer.ScheduledTimerTask">
<property name="timerTask">
<ref bean="MyTimeTask"/>
</property>
<property name="delay">
<value>10000</value>
</property>
<property name="period">
<value>86400000</value>
</property>
</bean>
</beans>

以上內容轉載自：http://dev.csdn.net/author/xtpdcsse/ec8e8080a5b04fa79e7d4828bc807d3f.html

下面是個人實現。

1）利用java.util.Timer. 代碼以下

<1>StartThread.java

[java]view plaincopy 
       
 package com.jview.main;<BR>
 import java.util.Date;<BR>
 import java.util.Timer;<BR>
 import java.util.TimerTask;<BR>
 import org.apache.log4j.Logger;<BR>
 public class StartThreadextends Thread {<BR>
 private static Logger logger = Logger.getLogger("StartThread");<BR>
 public static final int EXECUTE_CYC = 86400000; //24*60*60*1000毫秒<BR>
 int startH = 9;<BR>
 int startM = 52;<BR>
 private Timer _timer ;<BR>
 private Date _statDate;<BR>
 private Date _nowDate;<BR>
 public StartThread(){<BR>
 _nowDate = new Date();<BR>
 _timer = new Timer();<BR>
 _statDate = newDate(_nowDate.getYear(),_nowDate.getMonth(),_nowDate.getDate(),startH,startM);<BR>
 }<BR>
 public void StartUp(){<BR>
 _timer.schedule(<BR>
 new TimerTask() {<BR>
 public void run()<BR>
 {<BR>
 logger.info("開始統計...");<BR>
 try {<BR>
 Class.forName("com.jview.stat.StatPlan").newInstance();<BR>
 } catch (InstantiationException e) {<BR>
 // TODO Auto-generated catch block<BR>
 e.printStackTrace();<BR>
 } catch (IllegalAccessException e) {<BR>
 // TODO Auto-generated catch block<BR>
 e.printStackTrace();<BR>
 } catch (ClassNotFoundException e) {<BR>
 // TODO Auto-generated catch block<BR>
 e.printStackTrace();<BR>
 }<BR>
 }<BR>
 },_statDate,EXECUTE_CYC);<BR>
 }<BR>
 public static void main(String[] args) {<BR>
 StartThread _statUp = new StartThread();<BR>
 _statUp.StartUp();<BR>
 } <BR>
 }

[java]view plaincopy 
       
 package com.jview.main;  
   
 import java.util.Date;  
   
 import java.util.Timer;  
   
 import java.util.TimerTask;  
   
 import org.apache.log4j.Logger;  
   
 public class StartThread extends Thread {  
   
     private static Logger logger = Logger.getLogger("StartThread");  
   
     public static final int EXECUTE_CYC = 86400000; //24*60*60*1000毫秒  
   
     int startH = 9;  
   
     int startM = 52;  
   
     private Timer _timer ;  
   
     private Date _statDate;  
   
     private Date _nowDate;  
   
     public StartThread(){  
   
         _nowDate = new Date();  
   
         _timer = new Timer();  
   
         _statDate = new Date(_nowDate.getYear(),_nowDate.getMonth(),_nowDate.getDate(),startH,startM);  
   
     }  
   
     public void StartUp(){  
   
         _timer.schedule(  
   
                 new TimerTask() {  
   
                     public void run()  
   
                     {  
   
                         logger.info("開始統計...");  
   
                         try {  
   
                             Class.forName("com.jview.stat.StatPlan").newInstance();  
   
                         } catch (InstantiationException e) {  
   
                             // TODO Auto-generated catch block  
   
                             e.printStackTrace();  
   
                         } catch (IllegalAccessException e) {  
   
                             // TODO Auto-generated catch block  
   
                             e.printStackTrace();  
   
                         } catch (ClassNotFoundException e) {  
   
                             // TODO Auto-generated catch block  
   
                             e.printStackTrace();  
   
                         }  
   
                     }  
   
                 },_statDate,EXECUTE_CYC);  
   
     }  
   
     public static void main(String[] args) {  
   
         StartThread _statUp = new StartThread();  
   
         _statUp.StartUp();  
   
     }     
   
 }

<2>StatPlan.java

[java]view plaincopy 
       
 package com.jview.stat;<BR>
 import java.util.Calendar;<BR>
 import org.apache.log4j.Logger;<BR>
 public class StatPlan {<BR>
 <BR>
 <BR>
 private static Logger logger = Logger.getLogger("StatPlan");<BR>
 private int i = 0;<BR>
 private StatPlanService _sps ;<BR>
 public StatPlan(){<BR>
 _sps = new StatWeekPlan();<BR>
 statPlan();<BR>
 }<BR>
 <BR>
 public void statPlan(){<BR>
 Calendar _c = Calendar.getInstance();<BR>
 logger.info("stat plan ... 執行"+ i +"次,時間："+_c.getTime());<BR>
 _sps.StatPlan();<BR>
 i++;<BR>
 for(int i = 0; i<9999;i++){<BR>
 if(i==0 || i==9998){<BR>
 logger.info(""+i);<BR>
 }<BR>
 }<BR>
 }<BR>
 }

[java]view plaincopy 
       
 package com.jview.stat;  
   
 import java.util.Calendar;  
   
 import org.apache.log4j.Logger;  
   
 public class StatPlan {  
   
     private static Logger logger = Logger.getLogger("StatPlan");  
   
     private int i = 0;  
   
     private StatPlanService _sps ;  
   
     public StatPlan(){  
   
         _sps = new StatWeekPlan();  
   
         statPlan();  
   
     }  
   
     public void statPlan(){  
   
         Calendar _c = Calendar.getInstance();  
   
         logger.info("stat plan ... 執行"+ i +"次,時間："+_c.getTime());  
   
         _sps.StatPlan();  
   
         i++;  
   
         for(int i = 0; i<9999;i++){  
   
             if(i==0 || i== 9998){  
   
                 logger.info(""+i);  
   
             }  
   
         }  
   
     }  
   
 }

<3>StatWeekPlan .java

[java]view plaincopy 
       
 import org.apache.log4j.Logger;<BR>
 <BR>
 public class StatWeekPlanextends StatPlanService {<BR>
 private static Logger logger = Logger.getLogger("StatWeekPlan");<BR>
 public void StatPlan(){<BR>
 logger.info("this is statWeekPlan");<BR>
 }<BR>
 }<BR>
 <4>StatPlanService .java<BR>
 public class StatPlanService {<BR>
 public void StatPlan(){ <BR>
 }<BR>
 }

[java]view plaincopy 
       
 import org.apache.log4j.Logger;  
   
 public class StatWeekPlan extends StatPlanService {  
   
     private static Logger logger = Logger.getLogger("StatWeekPlan");  
   
     public void StatPlan(){  
   
         logger.info("this is statWeekPlan");  
   
     }  
   
 }  
   
 <4>StatPlanService .java  
   
 public class StatPlanService {  
   
     public void StatPlan(){      
   
     }  
   
 }

2）ServletContextListener.實現
<1> SysStatListener .java

[java]view plaincopy 
       
 import java.util.Date;<BR>
 import java.util.Timer;<BR>
 import java.util.TimerTask;<BR>
 import javax.servlet.ServletContextEvent;<BR>
 import javax.servlet.ServletContextListener;<BR>
 import org.apache.log4j.Logger;<BR>
 public class SysStatListenerimplements ServletContextListener{<BR>
 private static Logger logger = Logger.getLogger("ListByDayListener");<BR>
 private StatTask _sTask;<BR>
 public void contextDestroyed(ServletContextEvent scevent) {<BR>
 String status = "中止系通通計線程";<BR>
 scevent.getServletContext().log(status);<BR>
 logger.info(status);<BR>
 _sTask.shutDown();<BR>
 }<BR>
 public void contextInitialized(ServletContextEvent scevent) {<BR>
 String status = "啓動系通通計線程";<BR>
 scevent.getServletContext().log(status);<BR>
 logger.info(status);<BR>
 _sTask = new StatTask();<BR>
 _sTask.startUp();<BR>
 }<BR>
 }

[java]view plaincopy 
       
 import java.util.Date;  
   
 import java.util.Timer;  
   
 import java.util.TimerTask;  
   
 import javax.servlet.ServletContextEvent;  
   
 import javax.servlet.ServletContextListener;  
   
 import org.apache.log4j.Logger;  
   
 public class SysStatListener implements ServletContextListener{  
   
     private static Logger logger = Logger.getLogger("ListByDayListener");  
   
     private StatTask _sTask;  
   
     public void contextDestroyed(ServletContextEvent scevent) {  
   
         String status = "中止系通通計線程";  
   
         scevent.getServletContext().log(status);  
   
         logger.info(status);  
   
         _sTask.shutDown();  
   
     }  
   
     public void contextInitialized(ServletContextEvent scevent) {  
   
         String status = "啓動系通通計線程";  
   
         scevent.getServletContext().log(status);  
   
         logger.info(status);  
   
         _sTask = new StatTask();  
   
         _sTask.startUp();  
   
     }  
   
 }

<2> StatTask .java

[java]view plaincopy 
       
 import java.util.Date;<BR>
 import java.util.Timer;<BR>
 import java.util.TimerTask;<BR>
 import org.apache.log4j.Logger;<BR>
 public class StatTaskextends Thread {<BR>
 private static Logger logger = Logger.getLogger("StartThread");<BR>
 public staticfinal int EXECUTE_CYC =86400000;<BR>
 int startH = 9;<BR>
 int startM = 52;<BR>
 private Timer _timer ;<BR>
 private Date _statDate;<BR>
 private Date _nowDate;<BR>
 public StatTask(){<BR>
 _nowDate = new Date();<BR>
 _timer = new Timer();<BR>
 _statDate = newDate(_nowDate.getYear(),_nowDate.getMonth(),_nowDate.getDate(),startH,startM);<BR>
 }<BR>
 public void startUp(){<BR>
 _timer.schedule(<BR>
 new TimerTask() {<BR>
 public void run()<BR>
 {<BR>
 logger.info("開始統計...");<BR>
 try {<BR>
 Class.forName("com.jview.stat.StatPlan").newInstance();<BR>
 } catch (InstantiationException e) {<BR>
 // TODO Auto-generated catch block<BR>
 e.printStackTrace();<BR>
 } catch (IllegalAccessException e) {<BR>
 // TODO Auto-generated catch block<BR>
 e.printStackTrace();<BR>
 } catch (ClassNotFoundException e) {<BR>
 // TODO Auto-generated catch block<BR>
 e.printStackTrace();<BR>
 }<BR>
 }<BR>
 },_statDate,EXECUTE_CYC);<BR>
 }<BR>
 public void shutDown(){<BR>
 _timer.cancel();<BR>
 }

[java]view plaincopy 
       
 import java.util.Date;  
   
 import java.util.Timer;  
   
 import java.util.TimerTask;  
   
 import org.apache.log4j.Logger;  
   
 public class StatTask extends Thread {  
   
     private static Logger logger = Logger.getLogger("StartThread");  
   
     public static final int EXECUTE_CYC = 86400000;  
   
     int startH = 9;  
   
     int startM = 52;  
   
     private Timer _timer ;  
   
     private Date _statDate;  
   
     private Date _nowDate;  
   
     public StatTask(){  
   
         _nowDate = new Date();  
   
         _timer = new Timer();  
   
         _statDate = new Date(_nowDate.getYear(),_nowDate.getMonth(),_nowDate.getDate(),startH,startM);  
   
     }  
   
     public void startUp(){  
   
         _timer.schedule(  
   
                 new TimerTask() {  
   
                     public void run()  
   
                     {  
   
                         logger.info("開始統計...");  
   
                           try {  
   
                               Class.forName("com.jview.stat.StatPlan").newInstance();  
   
                           } catch (InstantiationException e) {  
   
                               // TODO Auto-generated catch block  
   
                               e.printStackTrace();  
   
                           } catch (IllegalAccessException e) {  
   
                              // TODO Auto-generated catch block  
   
                               e.printStackTrace();  
   
                          } catch (ClassNotFoundException e) {  
   
                             // TODO Auto-generated catch block  
   
                              e.printStackTrace();  
   
                          }  
   
                     }  
   
                 },_statDate,EXECUTE_CYC);  
   
     }  
   
     public void shutDown(){  
   
         _timer.cancel();  
   
     }

<3>在web.xml中添加下面的內容（注：下面的內容放到<filter- mapping>的後面）
<listener>
<listener-class>com.jview.auto.stat.SysStatListener </listener-class>
</listener>

22:58
瀏覽 (583)
評論 (0)
分類: Java
收藏

2009 - 03 - 31

縮略顯示

13個代碼註釋的小技巧

這篇文章是由José M. Aguilar在他卓越的博客中以西班牙語的形式首發，其後Timm Martin在得到Aguilar先生的受權下，對該文章進行翻譯、修改，而且在DevTopics上發佈。

如下13個小技巧能夠使得你的代碼在長時間內依然可以保持容易理解和維護。

1. 對不一樣級別的代碼進行註釋

對於不一樣級別的代碼塊，要使用統一的方法來進行註釋。例如：

對於每個類，須要包含一段簡明扼要的描述，做者和上一次修改的時間
對於每個方法，須要包含這個方法的用途，功能，參數以及返回結果
當你在一個團隊裏面的時候，採用一套註釋的標準是很是重要的。固然，使用一種你們都承認的註釋約定和工具（例如C#的XML註釋和Java的Javadoc）在必定程度上能推進這項任務。

2. 使用段落註釋

首先把代碼塊分解成多個「段落」，每個段落都執行單一的任務；而後在每個「段落」開始以前添加註釋，告訴閱讀代碼的人接下來的這段代碼是幹什麼用的

// 檢查全部記錄都是正確的
foreach (Record record in records)
{
if (rec.checkStatus()==Status.OK)
{
. . .
}
}
// 如今開始進行處理
Context ctx = new ApplicationContext();
ctx.BeginTransaction();
. . .
3. 對齊註釋行

對於那些在行末寫有註釋的代碼，應該對齊註釋行來使得方便閱讀

const MAX_ITEMS = 10; // maximum number of packets
const MASK = 0x1F; // mask bit TCP

有些開發人員使用tab來對齊註釋，而另一些人會用空格來對齊。因爲tab在不一樣的編輯器和集成開發環境中會有所不一樣，因此最佳的方法是使用空格來對齊註釋行。

4. 不要侮辱閱讀者的智慧

要避免沒用的註釋，例如

if (a == 5) //若是a等於5
counter = 0 //把counte設爲0

這不單把時間浪費在寫沒用的註釋上面，同時也在分散讀者的注意力。

5. 要有禮貌

應當避免沒有禮貌的註釋，例如「要注意一些愚蠢的用戶會輸入一個負數」，或者「修正由菜鳥工程師寫的愚蠢得可憐的代碼而致使的反作用」。這樣的註釋對於代碼的寫註釋的人來講並無任何好處，同時你永遠都不會知道未來這些註釋會被誰來閱讀，你的老闆，一個客戶或者是剛纔被你數落的愚蠢得可憐的工程師。

6. 直截了當

不要在註釋裏面寫過多的廢話。避免在註釋裏面賣弄ASCII藝術，寫笑話，做詩和過於冗長。簡而言之就是保持註釋的簡單和直接。

7. 使用統一的風格

有些人以爲註釋應該讓非程序員也能看懂。另一些人以爲註釋須要面對的讀者只是程序員。不管如何，正如Successful Strategies for Commenting Code中所說的，最重要的是註釋的風格須要統一，而且老是面向相同的讀者。就本身而論，我懷疑非程序員是否會去讀代碼，因此我以爲註釋應該面向程序員來寫。

8. 在內部使用特殊的標籤

當你在一個團隊裏工做的時候，採用一組一致的標籤能幫助不一樣的程序員溝通。例如，不少團隊會採用「TODO」標籤來表示一段還沒有完成的代碼

int Estimate(int x, int y)
{
// TODO: implement the calculations
return 0;
}

標籤註釋並不會解釋代碼，它們尋求注意或者是傳遞信息。可是若是適當地使用這種技術，要記住跟進這段代碼而且完成該標籤傳遞的任務。

9. 在寫代碼的同時添加註釋

當你在寫代碼並且記憶猶新的同時就添加註釋。若是等到項目後期才添加註釋，會讓你事倍功半。「我沒有時間寫註釋」，「個人時間很緊迫」和「項目已經延遲了」，這些都是不寫註釋的常見藉口。有些工程師覺最佳的解決方法是「註釋先行」。例如：

public void ProcessOrder()
{
// Make sure the products are available
// Check that the customer is valid
// Send the order to the store
// Generate bill
}

10. 把本身想象爲註釋的讀者（事實上就是如此）

當你正在給代碼寫註釋的時候，不只僅爲往後維護你的代碼的開發者考慮，同時也設想一下若是本身就是註釋的讀者。Phil Haack曾經說過：

「一旦一行代碼被敲到文件中, 你就已經要開始維護那一行代碼了。」

因此，咱們本身就是好（或者壞）註釋的第一個受益者（或者受害者）。

11. 更新代碼的時候要更新註釋

若是註釋沒有隨着代碼的修改而更新，那麼這些註釋將是毫無心義的。代碼和註釋須要同步，不然註釋只會讓維護代碼的開發者更加痛苦。須要特別注意的是，一些重構的工具會自動更新代碼，可是卻沒有自動更新註釋，那麼註釋就天然而然地過時做廢了。

12. 良好可讀性代碼是註釋的金科玉律

對於不少開發者來講，一個基本的原則就是：讓代碼本身描述本身。雖然有人懷疑這是由不喜歡寫註釋的程序員所倡導的一場運動，可是無需解釋的代碼有很大的好處，這些代碼更加容易理解甚至讓註釋變得沒有必要。例如，在個人文章Fluid Interfaces中就給你們展現了什麼是清晰的無需解釋的代碼。

Calculator calc = new Calculator();
calc.Set(0);
calc.Add(10);
calc.Multiply(2);
calc.Subtract(4);
Console.WriteLine( 「Result: {0}」, calc.Get() );

在這個例子裏面，註釋就像是違反了第4條技巧那樣，變得毫無必要。要寫出可讀性好的代碼，你須要使用適當的命名方式（在經典的 Ottinger’s Rules中有闡述），保證恰當的縮進，而且採用編碼風格指導。若是代碼不遵照這條技巧，那麼註釋看起來就好像是爲本身很差的代碼的寫道歉信同樣。

13. 跟你的同事分享這些技巧

雖然從第10條技巧中咱們已經知道了本身就是好註釋的得益者，可是這些技巧對於全部的開發者來講都是頗有幫助的，尤爲是整個團隊都有相同共識的狀況下。所以，大方地跟你的同事去分享這些技巧，讓咱們寫出更加容易理解和維護的代碼。

08:43
瀏覽 (469)
評論 (0)
分類: Java
收藏

2009 - 03 - 10

縮略顯示

log4j配置文件的含義

今天試着用了一下log4j來處理java中的日誌，感受良好，順便記錄一下log4j的配置文件log4j.properties各語句的含義。

這是一個數據庫配置文件

#這是一個配置文件實例,PropertyConfigurator將使用這個文件 :
#聲明一個appender變量名爲JDBC
log4j.rootLogger=DEBUG, JDBC

#JDBC是一個JDBCAppender類，這個類能夠寫消息到數據庫
log4j.appender.JDBC=com.benqguru.palau.log.jdbc.test.JDBCAppender

#1.鏈接數據庫的數據庫選項
log4j.appender.JDBC.url=jdbc:mysql://localhost:3306/logtest
log4j.appender.JDBC.username=root
log4j.appender.JDBC.password=

#2.指定你本身的JDBCConnectionHandler的鏈接器選項
log4j.appender.JDBC.connection_class=com.benqguru.palau.log.jdbc.test.MyConnectionHandler

#3.指定一個靜態的SQL語句的SQL選項，這個語句將在每次消息事件發生時被執行
log4j.appender.JDBC.sql=INSERT INTO LOGTEST (id, msg, created_on, created_by) VALUES (1, @MSG@, sysdate, 'me')

#4. 指定數據庫中一個表的表選項。
log4j.appender.JDBC.table=logtest

#5.描述表的重要列的列選項(非空列是必須被描述的)
log4j.appender.JDBC.columns=id_seq~EMPTY id~ID~MyIDHandler msg~MSG created_on~TIMESTAMP created_by~STATIC~Thomas Fenner

#6.定義消息佈局器的佈局器選項(可選)
log4j.appender.JDBC.layout=org.apache.log4j.PatternLayout
log4j.appender.JDBC.layout.ConversionPattern=%m

#7.定義消息事件緩衝器的大小的緩衝器選項(可選)
log4j.appender.JDBC.buffer_size=1

#8.定義自動提交的提交選項(可選)
log4j.appender.JDBC.docommit=N

##########下面是英文說明#############
#Date - %d{DATE}[slf5s.DATE]
#Priority - %p[slf5s.PRIORITY]
#NDC - %x[slf5s.NDC]
#Thread - %t[slf5s.THREAD]
#Category - %c[slf5s.CATEGORY]
#Location - %l[slf5s.LOCATION]
#Message - %m[slf5s.MESSAGE]
#
#log4j.appender.R.layout.ConversionPattern=[slf5s.start]%d{DATE}[slf5s.DATE]%n/
# %p[slf5s.PRIORITY]%n%x[slf5s.NDC]%n%t[slf5s.THREAD]%n/
# %c[slf5s.CATEGORY]%n%l[slf5s.LOCATION]%n%m[slf5s.MESSAGE]%n%n
##########下面是中文說明#############
#%m 輸出代碼中指定的消息
#%p 輸出優先級，即DEBUG，INFO，WARN，ERROR，FATAL
#%r 輸出自應用啓動到輸出該log信息耗費的毫秒數
#%c 輸出所屬的類目，一般就是所在類的全名
#%t 輸出產生該日誌事件的線程名
#%n 輸出一個回車換行符，Windows平臺爲「/r/n」，Unix平臺爲「/n」
#%d 輸出日誌時間點的日期或時間，默認格式爲ISO8601，也能夠在其後指定格式，
#好比：%d{yyy MMM dd HH:mm:ss,SSS}，輸出相似：2002年10月18日 22：10：28，921
#%l 輸出日誌事件的發生位置，包括類目名、發生的線程，以及在代碼中的行數。舉例：Testlog4.main(TestLog4.java:10)

這是一個普通的配置文件

#log4j會解析這個文件
log4j.debug=false
#暫時還不清楚這兩個屬性的做用
log4j.disableOverride=true
log4j.disable=INFO
#設置記錄全部類的日誌的優先級別
log4j.rootLogger=DEBUG,dest1,dest2
#設置這個包記錄日誌爲假的話
#dist1,dist2就不會記錄com.benqguru.commons.logging.test.LoggingSample的日誌,只有dist3會記錄.
#反之,會記錄,這樣就會重複記錄
log4j.additivity.com.benqguru.commons.logging.test.LoggingSample=false
#特別指定某個特殊包的日誌級別和目標設備
log4j.category.com.benqguru.commons.logging.test.LoggingSample=WARN, dest3
#這個目標設備用來debug
log4j.appender.dest1=org.apache.log4j.ConsoleAppender
#log4j.appender.dest1.layout=org.apache.log4j.SimpleLayout
log4j.appender.dest1.layout=org.apache.log4j.PatternLayout
#%-4r %-5p [%t] %37c %3x - %m%n
log4j.appender.dest1.layout.ConversionPattern=%d %p %c - <%m> (%F.%M:%L) %t%n

#這個目標設備用來trace
log4j.appender.dest2=org.apache.log4j.RollingFileAppender
#該文件記錄日誌的級別(INFO如下的級別不記錄)
log4j.appender.dest2.Threshold=INFO
#文件保存路徑
log4j.appender.dest2.File=c:/log4jlog.htm
#是否往文件追加信息
log4j.appender.dest2.Append=true
#設置文件最大值
log4j.appender.dest2.MaxFileSize=5KB
#設置備份文件的最大數量
log4j.appender.dest2.MaxBackupIndex=10
#使用一個html格式來記錄日誌
log4j.appender.dest2.layout=org.apache.log4j.HTMLLayout
#是否打印該消息的代碼行
log4j.appender.dest2.layout.LocationInfo=true
#設置該日誌的html的標題
log4j.appender.dest2.layout.Title=My app title

#這個目標設備用來trace指定類或包
log4j.appender.dest3=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.dest3.Threshold=DEBUG
log4j.appender.dest3.File=c:/SpecPackageLog.htm
log4j.appender.dest3.Append=false
log4j.appender.dest3.layout=org.apache.log4j.HTMLLayout
log4j.appender.dest3.layout.LocationInfo=true
log4j.appender.dest3.layout.Title=My app title

13:37
瀏覽 (896)
評論 (2)
分類: Java
收藏

2009 - 03 - 10

縮略顯示

Java Regex(Java正則表達式)

在Sun的API中對在對「最大匹配Greedy」「最小匹配Reluctant」「徹底匹配Possessive」的描述，不能讓我明白他們有什麼區別，如今將我對這三種匹配模式的理解寫出來，供你們參考。

一、Greediness（貪心）匹配：

X?、X*、X+、X{n，}都是最大匹配。例如你要用「<.+>」去匹配「a<tr>aava </tr>abb」，也許你所期待的結果是想匹配「<tr>」，可是實際結果卻會匹配到「<tr>aava </tr>」。這是爲何呢？下面咱們跟蹤下最大匹配的匹配過程。

①「<」匹配字符串的「<」。②「.+」匹配字符串的「tr>aava </tr>ab」，在進行最大匹配時，它把兩個「>」都匹配了，它匹配了全部字符，直到文本的最後字符「b」 ③這時，發現不能成功匹配「>」，開始按原路回退，用「a」與「>」匹配，直到「ab」前面的「>」匹配成功。

二、Reluctant(Laziness)最小匹配

X?、X*、X+、X{n，}都是最大匹配。好，加個？就成了Laziness匹配。例如X??、X*?、X+?、X{n，}?都是最小匹配，其實X{n，m}?和X{n }?有些多餘。

最小匹配意味者，.+? 匹配一個字符後，立刻試一試>的匹配可能，失敗了，則.+? 再匹配一個字符，再立刻試一試>的匹配可能。JDK文檔中Greedy 和 Reluctant，它是以eat一口來隱喻的，因此翻譯成貪吃和（勉強的）厭食最貼切了。不過我喜歡最大匹配、最小匹配的說法。

三、Possessive徹底匹配

與最大匹配不一樣，還有一種匹配形式：X?+、X*+、X++、X{n，}+等，成爲徹底匹配。它和最大匹配同樣，一直匹配全部的字符，直到文本的最後，但它不禁原路返回。也就是說，一口匹配，搞不定就算了，到也乾脆，偶喜歡。

Use a possessive quantifier for situations where you want to seize all of something without ever backing off; it will outperform the equivalent greedy quantifier in cases where the match is not immediately found.

13:35
瀏覽 (2123)
評論 (0)
分類: Java
收藏

2009 - 03 - 05

縮略顯示

學習正則表達式最佳的材料

[java]view plaincopy 
       
 import java.util.regex.Matcher;<BR>
 import java.util.regex.Pattern;<BR>
 <BR>
 public class RegularExpression {<BR>
 <BR>
 public static void main(String[] args) {<BR>
 // 簡單認識正則表達式的概念<BR>
 <BR>
 // p("abc".matches("..."));<BR>
 // p("a8729a".replaceAll("//d", "-"));<BR>
 // Pattern p = Pattern.compile("[a-z]{3}");<BR>
 // Matcher m = p.matcher("fgh");<BR>
 // p(m.matches());<BR>
 // p("aaas".matches("[a-z]{3,}"));<BR>
 <BR>
 // 初步認識. * + ?<BR>
 <BR>
 // p("a".matches("."));<BR>
 // p("aa".matches("aa"));<BR>
 // p("aaaa".matches("a*"));<BR>
 // p("aaaa".matches("a+"));<BR>
 // p("".matches("a*"));<BR>
 // p("aaaa".matches("a?"));<BR>
 // p("".matches("a?"));<BR>
 // p("a".matches("a?"));<BR>
 // p("214523145234532".matches("//d{3,100}"));<BR>
 // p("192.168.0.231".matches("//d{1,3}//.//d{1,3}//.//d{1,3}//.//d{1,3}"));<BR>
 // p("192".matches("[0-2][0-9][0-9]"));<BR>
 <BR>
 // 範圍<BR>
 <BR>
 // p("a".matches("[abc]"));<BR>
 // p("a".matches("[^abc]"));<BR>
 // p("A".matches("[a-zA-Z]"));<BR>
 // p("a".matches("[a-z]|[A-Z]"));<BR>
 // p("A".matches("[a-z[A-Z]]"));<BR>
 // p("R".matches("[A-Z&&[RFG]]"));<BR>
 <BR>
 // 認識/s /w /d /<BR>
 <BR>
 // p(" /n/r/t".matches("//s{4}"));<BR>
 // p(" ".matches("//S"));<BR>
 // p("a_8".matches("//w{3}"));<BR>
 // p("abc888&^%".matches("[a-z]{1,3}//d+[&^#%]+"));<BR>
 // p("//".matches("////"));<BR>
 <BR>
 // POSIX Style<BR>
 <BR>
 // p("a".matches("//p{Lower}"));<BR>
 <BR>
 // boundary<BR>
 <BR>
 // p("hello sir".matches("^h.*"));<BR>
 // p("hello sir".matches(".*ir$"));<BR>
 // p("hello sir".matches("^h[a-z]{1,3}o//b.*"));<BR>
 // p("hellosir".matches("^h[a-z]{1,3}o//b.*")); // whilte lines<BR>
 // p("/n".matches("^[//s&&[^//n<BR>
 // p("aaa 8888c".matches(".*//d{4}."));<BR>
 // p("aaa8888c".matches(".*//b//d{4}."));<BR>
 // p("aaa8888c".matches(".*//d{4}."));<BR>
 // p("aaa 8888c".matches(".*//b//d{4}."));<BR>
 <BR>
 // email<BR>
 <BR>
 // p("asdfasdfsafsf@dsdfsdf.com".matches("[//w[.-]]+@[//w[.-]]+//.[//w]+"));<BR>
 <BR>
 // matches find lookingAt<BR>
 <BR>
 // Pattern p = Pattern.compile("//d{3,5}");<BR>
 // String s = "123-34345-234-00";<BR>
 // Matcher m = p.matcher(s);<BR>
 // p(m.matches());<BR>
 // m.reset();<BR>
 // p(m.find());<BR>
 // p(m.start() + "-" + m.end());<BR>
 // p(m.find());<BR>
 // p(m.start() + "-" + m.end());<BR>
 // p(m.find());<BR>
 // p(m.start() + "-" + m.end());<BR>
 // p(m.find());<BR>
 // //p(m.start() + "-" + m.end());<BR>
 // p(m.lookingAt());<BR>
 // p(m.lookingAt());<BR>
 // p(m.lookingAt());<BR>
 // p(m.lookingAt());<BR>
 <BR>
 // replacement<BR>
 <BR>
 // Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);<BR>
 // Matcher m = p<BR>
 // .matcher("java Java JAVa JaVa IloveJAVA you hateJava afasdfasdf");<BR>
 // StringBuffer buf = new StringBuffer();<BR>
 // int i = 0;<BR>
 // while (m.find()) {<BR>
 // i++;<BR>
 // if (i % 2 == 0) {<BR>
 // m.appendReplacement(buf, "java");<BR>
 // } else {<BR>
 // m.appendReplacement(buf, "JAVA");<BR>
 // }<BR>
 // }<BR>
 // m.appendTail(buf);<BR>
 // p(buf);<BR>
 <BR>
 // group<BR>
 <BR>
 // Pattern p = Pattern.compile("(//d{3,5})([a-z]{2})");<BR>
 // String s = "123aa-34345bb-234cc-00";<BR>
 // Matcher m = p.matcher(s);<BR>
 // while (m.find()) {<BR>
 // p(m.group());<BR>
 // }<BR>
 <BR>
 // qulifiers<BR>
 <BR>
 // Pattern p = Pattern.compile(".{3,10}+[0-9]");<BR>
 // String s = "aaaa5bbbb68";<BR>
 // Matcher m = p.matcher(s);<BR>
 // if (m.find())<BR>
 // p(m.start() + "-" + m.end());<BR>
 // else<BR>
 // p("not match!");<BR>
 <BR>
 // non-capturing groups<BR>
 <BR>
 // Pattern p = Pattern.compile(".{3}(?=a)");<BR>
 // String s = "444a66b";<BR>
 // Matcher m = p.matcher(s);<BR>
 // while (m.find()) {<BR>
 // p(m.group());<BR>
 // }<BR>
 <BR>
 // back refenrences<BR>
 <BR>
 // Pattern p = Pattern.compile("(//d(//d))//2");<BR>
 // String s = "122";<BR>
 // Matcher m = p.matcher(s);<BR>
 // p(m.matches());<BR>
 <BR>
 // flags的簡寫<BR>
 Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);<BR>
 p("Java".matches("(?i)(java)"));<BR>
 }<BR>
 <BR>
 public staticvoid p(Object o) {<BR>
 System.out.println(o);<BR>
 }<BR>
 <BR>
 }<BR>

[java]view plaincopy 
       
 import java.util.regex.Matcher;  
   
 import java.util.regex.Pattern;  
   
 public class RegularExpression {  
   
     public static void main(String[] args) {  
   
         // 簡單認識正則表達式的概念  
   
         // p("abc".matches("..."));  
   
         // p("a8729a".replaceAll("//d", "-"));  
   
         // Pattern p = Pattern.compile("[a-z]{3}");  
   
         // Matcher m = p.matcher("fgh");  
   
         // p(m.matches());  
   
         // p("aaas".matches("[a-z]{3,}"));  
   
         // 初步認識. * + ?  
   
         // p("a".matches("."));  
   
         // p("aa".matches("aa"));  
   
         // p("aaaa".matches("a*"));  
   
         // p("aaaa".matches("a+"));  
   
         // p("".matches("a*"));  
   
         // p("aaaa".matches("a?"));  
   
         // p("".matches("a?"));  
   
         // p("a".matches("a?"));  
   
         // p("214523145234532".matches("//d{3,100}"));  
   
         // p("192.168.0.231".matches("//d{1,3}//.//d{1,3}//.//d{1,3}//.//d{1,3}"));  
   
         // p("192".matches("[0-2][0-9][0-9]"));  
   
         // 範圍  
   
         // p("a".matches("[abc]"));  
   
         // p("a".matches("[^abc]"));  
   
         // p("A".matches("[a-zA-Z]"));  
   
         // p("a".matches("[a-z]|[A-Z]"));  
   
         // p("A".matches("[a-z[A-Z]]"));  
   
         // p("R".matches("[A-Z&&[RFG]]"));  
   
         // 認識/s /w /d /  
   
         // p(" /n/r/t".matches("//s{4}"));  
   
         // p(" ".matches("//S"));  
   
         // p("a_8".matches("//w{3}"));  
   
         // p("abc888&^%".matches("[a-z]{1,3}//d+[&^#%]+"));  
   
         // p("//".matches("////"));  
   
         // POSIX Style  
   
         // p("a".matches("//p{Lower}"));  
   
         // boundary  
   
         // p("hello sir".matches("^h.*"));  
   
         // p("hello sir".matches(".*ir$"));  
   
         // p("hello sir".matches("^h[a-z]{1,3}o//b.*"));  
   
         // p("hellosir".matches("^h[a-z]{1,3}o//b.*")); // whilte lines  
   
         // p("/n".matches("^[//s&&[^//n  
   
         // p("aaa 8888c".matches(".*//d{4}."));  
   
         // p("aaa8888c".matches(".*//b//d{4}."));  
   
         // p("aaa8888c".matches(".*//d{4}."));  
   
         // p("aaa 8888c".matches(".*//b//d{4}."));  
   
         // email  
   
         // p("asdfasdfsafsf@dsdfsdf.com".matches("[//w[.-]]+@[//w[.-]]+//.[//w]+"));  
   
         // matches find lookingAt  
   
         // Pattern p = Pattern.compile("//d{3,5}");  
   
         // String s = "123-34345-234-00";  
   
         // Matcher m = p.matcher(s);  
   
         // p(m.matches());  
   
         // m.reset();  
   
         // p(m.find());  
   
         // p(m.start() + "-" + m.end());  
   
         // p(m.find());  
   
         // p(m.start() + "-" + m.end());  
   
         // p(m.find());  
   
         // p(m.start() + "-" + m.end());  
   
         // p(m.find());  
   
         // //p(m.start() + "-" + m.end());  
   
         // p(m.lookingAt());  
   
         // p(m.lookingAt());  
   
         // p(m.lookingAt());  
   
         // p(m.lookingAt());  
   
         // replacement  
   
         // Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);  
   
         // Matcher m = p  
   
         // .matcher("java Java JAVa JaVa IloveJAVA you hateJava afasdfasdf");  
   
         // StringBuffer buf = new StringBuffer();  
   
         // int i = 0;  
   
         // while (m.find()) {  
   
         // i++;  
   
         // if (i % 2 == 0) {  
   
         // m.appendReplacement(buf, "java");  
   
         // } else {  
   
         // m.appendReplacement(buf, "JAVA");  
   
         // }  
   
         // }  
   
         // m.appendTail(buf);  
   
         // p(buf);  
   
         // group  
   
         // Pattern p = Pattern.compile("(//d{3,5})([a-z]{2})");  
   
         // String s = "123aa-34345bb-234cc-00";  
   
         // Matcher m = p.matcher(s);  
   
         // while (m.find()) {  
   
         // p(m.group());  
   
         // }  
   
         // qulifiers  
   
         // Pattern p = Pattern.compile(".{3,10}+[0-9]");  
   
         // String s = "aaaa5bbbb68";  
   
         // Matcher m = p.matcher(s);  
   
         // if (m.find())  
   
         // p(m.start() + "-" + m.end());  
   
         // else  
   
         // p("not match!");  
   
         // non-capturing groups  
   
         // Pattern p = Pattern.compile(".{3}(?=a)");  
   
         // String s = "444a66b";  
   
         // Matcher m = p.matcher(s);  
   
         // while (m.find()) {  
   
         // p(m.group());  
   
         // }  
   
         // back refenrences  
   
         // Pattern p = Pattern.compile("(//d(//d))//2");  
   
         // String s = "122";  
   
         // Matcher m = p.matcher(s);  
   
         // p(m.matches());  
   
         // flags的簡寫  
   
         Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);  
   
         p("Java".matches("(?i)(java)"));  
   
     }  
   
     public static void p(Object o) {  
   
         System.out.println(o);  
   
     }  
   
 }

14:05
瀏覽 (630)
評論 (1)
分類: Java
收藏

2009 - 02 - 06

縮略顯示

Java snippets02

[java]view plaincopy 
       
 if (Character.isLowerCase(ch[i])) {<BR>
 char temp = Character.toUpperCase(ch[i]);<BR>
 ch[i] = temp;<BR>
 } else if (Character.isUpperCase(ch[i])) {<BR>
 char temp = Character.toLowerCase(ch[i]);<BR>
 ch[i] = temp;<BR>
 }

[java]view plaincopy 
       
 if (Character.isLowerCase(ch[i])) {  
   
     char temp = Character.toUpperCase(ch[i]);  
   
     ch[i] = temp;  
   
 } else if (Character.isUpperCase(ch[i])) {  
   
     char temp = Character.toLowerCase(ch[i]);  
   
     ch[i] = temp;  
   
 }

[java]view plaincopy 
       
 while (true) {<BR>
 flag = 0;<BR>
 result = tc.getNum();<BR>
 >
 input = Integer.parseInt(br.readLine());<BR>
 >
 while (flag == 0) {<BR>
 if (input == result) {<BR>
 System.out.println("very good!");<BR>
 flag = 1;<BR>
 } else {<BR>
 flag = 0;<BR>
 System.out.println("no,please try again.");<BR>
 input = Integer.parseInt(br.readLine());<BR>
 }<BR>
 }<BR>
 }

[java]view plaincopy 
       
 while (true) {  
   
     flag = 0;  
   
     result = tc.getNum();  
   
     input = Integer.parseInt(br.readLine());  
   
     while (flag == 0) {  
   
         if (input == result) {  
   
             System.out.println("very good!");  
   
             flag = 1;  
   
         } else {  
   
             flag = 0;  
   
             System.out.println("no,please try again.");  
   
             input = Integer.parseInt(br.readLine());  
   
         }  
   
     }  
   
 }

[java]view plaincopy 
       
 L1: while (true) {<BR>
 int question = new Times().question();<BR>
 L2: while (true) {<BR>
 int answer = scanner.nextInt();<BR>
 if (answer == question) {<BR>
 System.out.println("very good!");<BR>
 continue L1;<BR>
 } else {<BR>
 System.out.println("no,please try again.");<BR>
 continue L2;<BR>
 }<BR>
 }<BR>
 }

[java]view plaincopy 
       
 L1: while (true) {  
   
     int question = new Times().question();  
   
     L2: while (true) {  
   
         int answer = scanner.nextInt();  
   
         if (answer == question) {  
   
             System.out.println("very good!");  
   
             continue L1;  
   
         } else {  
   
             System.out.println("no,please try again.");  
   
             continue L2;  
   
         }  
   
     }  
   
 }

[java]view plaincopy 
       
 char[] c1 = s1.toCharArray();

[java]view plaincopy 
       
 char[] c1 = s1.toCharArray();  

[java]view plaincopy 
       
 Map<Integer, String> m =new HashMap<Integer, String>();<BR>
 m.put(1, "one");<BR>
 m.put(2, "two");<BR>
 m.put(3, "three");<BR>
 Object o[] = m.values().toArray();

[java]view plaincopy 
       
 Map<Integer, String> m = new HashMap<Integer, String>();  
   
 m.put(1, "one");  
   
 m.put(2, "two");  
   
 m.put(3, "three");  
   
 Object o[] = m.values().toArray();

[java]view plaincopy 
       
 GregorianCalendar ca = new GregorianCalendar();<BR>
 System.out.println(ca.get(GregorianCalendar.AM_PM));

[java]view plaincopy 
       
 GregorianCalendar ca = new GregorianCalendar();  
   
 System.out.println(ca.get(GregorianCalendar.AM_PM));  

14:43
瀏覽 (360)
評論 (0)
分類: Java
收藏

2009 - 02 - 06

縮略顯示

Java snippets01

[java]view plaincopy 
       
 for (int i =0; i < number.length; i++) {<BR>
 for (int j = 0; j < number.length - i - 1; j++) {<BR>
 if (number[j] < number[j + 1]) {<BR>
 int temp = number[j];<BR>
 number[j] = number[j + 1];<BR>
 number[j + 1] = temp;<BR>
 }<BR>
 }<BR>
 }<BR>

[java]view plaincopy 
       
 for (int i = 0; i < number.length; i++) {  
   
     for (int j = 0; j < number.length - i - 1; j++) {  
   
         if (number[j] < number[j + 1]) {  
   
             int temp = number[j];  
   
             number[j] = number[j + 1];  
   
             number[j + 1] = temp;  
   
         }  
   
     }  
   
 }

[java]view plaincopy 
       
 BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));<BR>
 String str = buffer.readLine();

[java]view plaincopy 
       
 BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));  
   
 String str = buffer.readLine();  

[java]view plaincopy 
       
 Scanner scanner = new Scanner(System.in);<BR>
 String line = scanner.nextLine();

[java]view plaincopy 
       
 Scanner scanner = new Scanner(System.in);  
   
 String line = scanner.nextLine();  

[java]view plaincopy 
       
 InputStreamReader in = null;<BR>
 OutputStreamWriter out = null;<BR>
 BufferedReader br = null;<BR>
 <BR>
 in = new InputStreamReader(new FileInputStream(System<BR>
 .getProperty("user.dir")<BR>
 + "//old.txt"), "UTF-8");<BR>
 br = new BufferedReader(in);<BR>
 out = new OutputStreamWriter(new FileOutputStream(<BR>
 "C://WINDOWS//new.txt"), "UTF-8");

[java]view plaincopy 
       
 InputStreamReader in = null;  
   
 OutputStreamWriter out = null;  
   
 BufferedReader br = null;  
   
 in = new InputStreamReader(new FileInputStream(System  
   
                     .getProperty("user.dir")  
   
                     + "//old.txt"), "UTF-8");  
   
 br = new BufferedReader(in);  
   
 out = new OutputStreamWriter(new FileOutputStream(  
   
                     "C://WINDOWS//new.txt"), "UTF-8");

[java]view plaincopy 
       
 String[] temp;<BR>
 temp = text.split("//s{1,}");// 按照空格分割字符串，多個空格做爲一個空格對字符串進行分割

[java]view plaincopy 
       
 String[] temp;  
   
 temp = text.split("//s{1,}");// 按照空格分割字符串，多個空格做爲一個空格對字符串進行分割  

[java]view plaincopy 
       
 String s = String.valueOf(1);<BR>
 if (s.charAt(i) == '1'){}<BR>

[java]view plaincopy 
       
 String s = String.valueOf(1);  
   
 if (s.charAt(i) == '1'){}  

[java]view plaincopy 
       
 System.nanoTime();

[java]view plaincopy 
       
 System.nanoTime();  

[java]view plaincopy 
       
 SimpleDateFormat sdt = new SimpleDateFormat("yyyy-MM-DD HH:mm:ss");<BR>
 String date = sdt.format(System.currentTimeMillis());

[java]view plaincopy 
       
 SimpleDateFormat sdt = new SimpleDateFormat("yyyy-MM-DD HH:mm:ss");  
   
 String date = sdt.format(System.currentTimeMillis());  

[java]view plaincopy 
       
 DecimalFormat df = (DecimalFormat) NumberFormat.getInstance();<BR>
 df.applyPattern("00");

[java]view plaincopy 
       
 DecimalFormat df = (DecimalFormat) NumberFormat.getInstance();  
   
 df.applyPattern("00");  

[java]view plaincopy 
       
 Calendar current_time = new GregorianCalendar();<BR>
 Calendar target_time = new GregorianCalendar(2009, Calendar.MAY,1);<BR>
 long diffMillis = target_time.getTimeInMillis()<BR>
 - current_time.getTimeInMillis();<BR>
 long diffDays = diffMillis / (24 *60 * 60 * 1000) + 1;<BR>
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-DD");<BR>
 <BR>
 System.out.println("距" + sdf.format(target_time.getTimeInMillis())<BR>
 + "還有：" + diffDays + "天");

[java]view plaincopy 
       
 Calendar current_time = new GregorianCalendar();  
   
 Calendar target_time = new GregorianCalendar(2009, Calendar.MAY, 1);  
   
 long diffMillis = target_time.getTimeInMillis()  
   
         - current_time.getTimeInMillis();  
   
 long diffDays = diffMillis / (24 * 60 * 60 * 1000) + 1;  
   
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-DD");  
   
 System.out.println("距" + sdf.format(target_time.getTimeInMillis())  
   
         + "還有：" + diffDays + "天");

[java]view plaincopy 
       
 Arrays.sort(array);

[java]view plaincopy 
       
 Arrays.sort(array);  

[java]view plaincopy 
       
 StringBuilder s1 = new StringBuilder(temp);<BR>
 // StringBuffer s1 = new StringBuffer(temp);<BR>
 System.out.println(s1.reverse());

[java]view plaincopy 
       
 StringBuilder s1 = new StringBuilder(temp);  
   
 // StringBuffer s1 = new StringBuffer(temp);  
   
 System.out.println(s1.reverse());

13:28
瀏覽 (395)
評論 (0)
分類: Java
收藏

2009 - 02 - 06

縮略顯示

雙色球算號器

我是個彩民，特別喜歡買雙色球。最近看了幾種算法，寫了一個很簡單的雙色球的算號器，分享給你們，僅供娛樂，呵呵

[java]view plaincopy 
       
 package com.tester.luckly;<BR>
 <BR>
 import java.util.Random;<BR>
 import java.util.Scanner;<BR>
 import java.util.Set;<BR>
 import java.util.TreeSet;<BR>
 <BR>
 public class DoubleBall {<BR>
 private Set<Integer> hs;<BR>
 private static boolean flag = true;<BR>
 <BR>
 public enum oddOrEven {<BR>
 Odd, Even<BR>
 }<BR>
 <BR>
 public enum aOrBOrC {<BR>
 A, B, C<BR>
 }<BR>
 <BR>
 public static void main(String[] args) {<BR>
 DoubleBall db = new DoubleBall();<BR>
 System.out<BR>
 .println("====================Red Balls============================");<BR>
 String url1 = "http://map.zhcw.com/ssq//html/h7fenqu_ascstr=20.html";<BR>
 System.out.println();<BR>
 System.err.println(url1);<BR>
 Scanner scanner1 = new Scanner(System.in);<BR>
 System.out.println("Please select:1.Input your own two numbers");<BR>
 System.out<BR>
 .println(" 2.Input the range of the two numbers");<BR>
 int select = scanner1.nextInt();<BR>
 if (select == 1) {<BR>
 flag = false;<BR>
 } else {<BR>
 flag = true;<BR>
 }<BR>
 System.out.println("Please input two numbers like this: 1 2");<BR>
 scanner1.nextLine();<BR>
 String[] str = scanner1.nextLine().split(" ");<BR>
 Set<Integer> redBall = db.calcRedBall(Integer.parseInt(str[0]), Integer<BR>
 .parseInt(str[1]));<BR>
 <BR>
 System.out<BR>
 .println("====================Blue Ball============================");<BR>
 String url2 = "http://sports.sohu.com/s2007/0445/s252476794/";<BR>
 System.out.println();<BR>
 System.err.println(url2);<BR>
 Scanner scanner2 = new Scanner(System.in);<BR>
 <BR>
 System.out.println("1.Please select:" + oddOrEven.Odd +" or "<BR>
 + oddOrEven.Even);<BR>
 String select1 = scanner2.nextLine();<BR>
 <BR>
 System.out.println("2.Please select:" + aOrBOrC.A +" or " + aOrBOrC.B<BR>
 + " or " + aOrBOrC.C);<BR>
 String select2 = scanner2.nextLine();<BR>
 <BR>
 int blueBall = db.calcBlueBall(select1, select2);<BR>
 <BR>
 System.out<BR>
 .println("====================The Result============================");<BR>
 System.out.println();<BR>
 for (int i : redBall) {<BR>
 System.err.print(i + " ");<BR>
 }<BR>
 System.err.println("| " + blueBall);<BR>
 String url3 = "http://www.bwlc.net/dhtz/";<BR>
 System.err.println(url3);<BR>
 }<BR>
 <BR>
 public Set<Integer> calcRedBall(int begin,int end) {<BR>
 hs = new TreeSet<Integer>();<BR>
 <BR>
 /*<BR>
 * 固定恆碼：就是每期都必備的號碼，一般爲2-3個，如02，13，27。 這2-3個號碼長期備選（至少50期）。<BR>
 */<BR>
 hs.add(10);<BR>
 hs.add(27);<BR>
 <BR>
 /*<BR>
 * 邊緣撿「膽」:就是在邊緣碼「0五、十、1五、20、2五、30」及「0一、<BR>
 * 0六、十一、1六、2一、2六、31」共13個號碼中巧妙地撿出膽碼。之因此 把邊緣碼做爲「膽」碼的一種選取方法，是由於從歷史中獎號碼來看，<BR>
 * 幾乎每一期都會在具有這種特性的號碼中出現2-3個。<BR>
 */<BR>
 int[] array = { 5, 15, 20, 25, 30, 01, 06, 11, 16, 21, 26, 31 };<BR>
 for (int i = 0; i < 2; i++) {<BR>
 Random random = new Random();<BR>
 hs.add(array[random.nextInt(array.length)]);<BR>
 }<BR>
 <BR>
 /*<BR>
 * 重碼追鄰：在上上期出號的左右選取的上期號碼，這話很差理解，現舉例說明：雙色球2007109期開01 04 07 08 13 14；<BR>
 * 110期開02 04 07 15 24 28；其中這期的04<BR>
 * 07，恰好是109期2、三位的重碼，那麼111期的重碼該選取哪一個呢？重碼追鄰就是在110期的04 07 的左右選取，110期04 07<BR>
 * 的左右是02 15。因此111期的備選號就是02 15 了。實際上111期重碼恰好開的是02。重碼追鄰通常選取2-3個號碼。<BR>
 */<BR>
 /* ========= 或者========= */<BR>
 /* 旺區落「膽」。就是在最近幾期熱號區選擇膽碼。好比，若是最近的5期內，在中區12~22出號比較密集，那麼就要在這個區域裏選取3個膽碼。這樣選擇的理由是熱碼恆熱原理，即號碼老是在某個區域相對集中出現。 */<BR>
 if (flag == true) {<BR>
 hs.add(begin);<BR>
 hs.add(end);<BR>
 } else {<BR>
 Random random = new Random();<BR>
 hs.add(begin + random.nextInt(end - begin + 1));<BR>
 }<BR>
 /* Luck number! */<BR>
 while (hs.size() < 6) {<BR>
 Random random = new Random();<BR>
 hs.add(1 + random.nextInt(33));<BR>
 }<BR>
 <BR>
 return hs;<BR>
 }<BR>
 <BR>
 public int calcBlueBall(String select1, String select2) {<BR>
 int begin = 1;<BR>
 int end = 16;<BR>
 <BR>
 if (select2.equals(aOrBOrC.A.toString())) {<BR>
 begin = 1;<BR>
 end = 5;<BR>
 } else if (select2.equals(aOrBOrC.B.toString())) {<BR>
 begin = 6;<BR>
 end = 10;<BR>
 } else {<BR>
 begin = 11;<BR>
 end = 16;<BR>
 }<BR>
 <BR>
 Random random = new Random();<BR>
 int blueBall = begin + random.nextInt(end - begin +1);<BR>
 if (select1.equals(oddOrEven.Odd.toString())) {<BR>
 while (blueBall % 2 == 0) {<BR>
 blueBall = begin + random.nextInt(end - begin + 1);<BR>
 }<BR>
 } else {<BR>
 while (blueBall % 2 == 1) {<BR>
 blueBall = begin + random.nextInt(end - begin + 1);<BR>
 }<BR>
 }<BR>
 <BR>
 return blueBall;<BR>
 }<BR>
 }

[java]view plaincopy 
       
 package com.tester.luckly;  
   
 import java.util.Random;  
   
 import java.util.Scanner;  
   
 import java.util.Set;  
   
 import java.util.TreeSet;  
   
 public class DoubleBall {  
   
     private Set<Integer> hs;  
   
     private static boolean flag = true;  
   
     public enum oddOrEven {  
   
         Odd, Even  
   
     }  
   
     public enum aOrBOrC {  
   
         A, B, C  
   
     }  
   
     public static void main(String[] args) {  
   
         DoubleBall db = new DoubleBall();  
   
         System.out  
   
                 .println("====================Red Balls============================");  
   
         String url1 = "http://map.zhcw.com/ssq//html/h7fenqu_ascstr=20.html";  
   
         System.out.println();  
   
         System.err.println(url1);  
   
         Scanner scanner1 = new Scanner(System.in);  
   
         System.out.println("Please select:1.Input your own two numbers");  
   
         System.out  
   
                 .println("              2.Input the range of the two numbers");  
   
         int select = scanner1.nextInt();  
   
         if (select == 1) {  
   
             flag = false;  
   
         } else {  
   
             flag = true;  
   
         }  
   
         System.out.println("Please input two numbers like this: 1 2");  
   
         scanner1.nextLine();  
   
         String[] str = scanner1.nextLine().split(" ");  
   
         Set<Integer> redBall = db.calcRedBall(Integer.parseInt(str[0]), Integer  
   
                 .parseInt(str[1]));  
   
         System.out  
   
                 .println("====================Blue Ball============================");  
   
         String url2 = "http://sports.sohu.com/s2007/0445/s252476794/";  
   
         System.out.println();  
   
         System.err.println(url2);  
   
         Scanner scanner2 = new Scanner(System.in);  
   
         System.out.println("1.Please select:" + oddOrEven.Odd + " or "  
   
                 + oddOrEven.Even);  
   
         String select1 = scanner2.nextLine();  
   
         System.out.println("2.Please select:" + aOrBOrC.A + " or " + aOrBOrC.B  
   
                 + " or " + aOrBOrC.C);  
   
         String select2 = scanner2.nextLine();  
   
         int blueBall = db.calcBlueBall(select1, select2);  
   
         System.out  
   
                 .println("====================The Result============================");  
   
         System.out.println();  
   
         for (int i : redBall) {  
   
             System.err.print(i + " ");  
   
         }  
   
         System.err.println("| " + blueBall);  
   
         String url3 = "http://www.bwlc.net/dhtz/";  
   
         System.err.println(url3);  
   
     }  
   
     public Set<Integer> calcRedBall(int begin, int end) {  
   
         hs = new TreeSet<Integer>();  
   
         /* 
  
          * 固定恆碼：就是每期都必備的號碼，一般爲2-3個，如02，13，27。 這2-3個號碼長期備選（至少50期）。 
  
          */  
   
         hs.add(10);  
   
         hs.add(27);  
   
         /* 
  
          * 邊緣撿「膽」:就是在邊緣碼「0五、十、1五、20、2五、30」及「0一、 
  
          * 0六、十一、1六、2一、2六、31」共13個號碼中巧妙地撿出膽碼。之因此 把邊緣碼做爲「膽」碼的一種選取方法，是由於從歷史中獎號碼來看， 
  
          * 幾乎每一期都會在具有這種特性的號碼中出現2-3個。 
  
          */  
   
         int[] array = { 5, 15, 20, 25, 30, 01, 06, 11, 16, 21, 26, 31 };  
   
         for (int i = 0; i < 2; i++) {  
   
             Random random = new Random();  
   
             hs.add(array[random.nextInt(array.length)]);  
   
         }  
   
         /* 
  
          * 重碼追鄰：在上上期出號的左右選取的上期號碼，這話很差理解，現舉例說明：雙色球2007109期開01 04 07 08 13 14； 
  
          * 110期開02 04 07 15 24 28；其中這期的04 
  
          * 07，恰好是109期2、三位的重碼，那麼111期的重碼該選取哪一個呢？重碼追鄰就是在110期的04 07 的左右選取，110期04 07 
  
          * 的左右是02 15。因此111期的備選號就是02 15 了。實際上111期重碼恰好開的是02。重碼追鄰通常選取2-3個號碼。 
  
          */  
   
         /* ========= 或者========= */  
   
         /* 旺區落「膽」。就是在最近幾期熱號區選擇膽碼。好比，若是最近的5期內，在中區12~22出號比較密集，那麼就要在這個區域裏選取3個膽碼。這樣選擇的理由是熱碼恆熱原理，即號碼老是在某個區域相對集中出現。 */  
   
         if (flag == true) {  
   
             hs.add(begin);  
   
             hs.add(end);  
   
         } else {  
   
             Random random = new Random();  
   
             hs.add(begin + random.nextInt(end - begin + 1));  
   
         }  
   
         /* Luck number! */  
   
         while (hs.size() < 6) {  
   
             Random random = new Random();  
   
             hs.add(1 + random.nextInt(33));  
   
         }  
   
         return hs;  
   
     }  
   
     public int calcBlueBall(String select1, String select2) {  
   
         int begin = 1;  
   
         int end = 16;  
   
         if (select2.equals(aOrBOrC.A.toString())) {  
   
             begin = 1;  
   
             end = 5;  
   
         } else if (select2.equals(aOrBOrC.B.toString())) {  
   
             begin = 6;  
   
             end = 10;  
   
         } else {  
   
             begin = 11;  
   
             end = 16;  
   
         }  
   
         Random random = new Random();  
   
         int blueBall = begin + random.nextInt(end - begin + 1);  
   
         if (select1.equals(oddOrEven.Odd.toString())) {  
   
             while (blueBall % 2 == 0) {  
   
                 blueBall = begin + random.nextInt(end - begin + 1);  
   
             }  
   
         } else {  
   
             while (blueBall % 2 == 1) {  
   
                 blueBall = begin + random.nextInt(end - begin + 1);  
   
             }  
   
         }  
   
         return blueBall;  
   
     }  
   
 }

12:29
瀏覽 (2864)
論壇瀏覽 (4047)
評論 (7)
分類: Java
收藏

2009 - 02 - 05

縮略顯示

關於用Java I/O 複製文件的問題

今天遇到了一個極其鬱悶的問題，想寫一段代碼，能夠給windows自動安裝一種字體。
原理就是將4個ttf字體文件複製到C://WINDOWS//Fonts//目錄下。原本覺得很簡單，但用java I/O複製過去的字體不能使用（將記事本的字體改爲DejaVuSansMono，若是有效果變化，就是正常的），直接手動複製一樣的文件過去，就能夠使用。不知道問題出在哪裏？
哪位朋友幫忙看看，萬分感謝，字體文件在附件中，代碼以下：

[java]view plaincopy 
       
 package com.test;<BR>
 import java.io.FileInputStream;<BR>
 import java.io.FileOutputStream;<BR>
 import java.io.IOException;<BR>
 import java.nio.channels.FileChannel;<BR>
 <BR>
 public class FontInstall {<BR>
 <BR>
 public staticvoid main(String[] args) {<BR>
 try {<BR>
 String[] fonts = { "DejaVuSansMono-Oblique.ttf",<BR>
 "DejaVuSansMono-BoldOblique.ttf", "DejaVuSansMono.ttf",<BR>
 "DejaVuSansMono-Bold.ttf" };<BR>
 System.out.println();<BR>
 for (int i =0; i < fonts.length; i++) {<BR>
 // Create channel on the source<BR>
 FileChannel srcChannel = new FileInputStream(System<BR>
 .getProperty("user.dir")<BR>
 + "//" + fonts[i]).getChannel();<BR>
 <BR>
 // Create channel on the destination<BR>
 FileChannel dstChannel = new FileOutputStream(<BR>
 "C://WINDOWS//Fonts//" + fonts[i]).getChannel();<BR>
 <BR>
 // Copy file contents from source to destination<BR>
 dstChannel.transferFrom(srcChannel, 0, srcChannel.size());<BR>
 <BR>
 // Close the channels<BR>
 srcChannel.close();<BR>
 dstChannel.close();<BR>
 }<BR>
 } catch (IOException e) {<BR>
 }<BR>
 }<BR>
 }<BR>

[java]view plaincopy 
       
 package com.test;  
   
 import java.io.FileInputStream;  
   
 import java.io.FileOutputStream;  
   
 import java.io.IOException;  
   
 import java.nio.channels.FileChannel;  
   
 public class FontInstall {  
   
     public static void main(String[] args) {  
   
         try {  
   
             String[] fonts = { "DejaVuSansMono-Oblique.ttf",  
   
                     "DejaVuSansMono-BoldOblique.ttf", "DejaVuSansMono.ttf",  
   
                     "DejaVuSansMono-Bold.ttf" };  
   
             System.out.println();  
   
             for (int i = 0; i < fonts.length; i++) {  
   
                 // Create channel on the source  
   
                 FileChannel srcChannel = new FileInputStream(System  
   
                         .getProperty("user.dir")  
   
                         + "//" + fonts[i]).getChannel();  
   
                 // Create channel on the destination  
   
                 FileChannel dstChannel = new FileOutputStream(  
   
                         "C://WINDOWS//Fonts//" + fonts[i]).getChannel();  
   
                 // Copy file contents from source to destination  
   
                 dstChannel.transferFrom(srcChannel, 0, srcChannel.size());  
   
                 // Close the channels  
   
                 srcChannel.close();  
   
                 dstChannel.close();  
   
             }  
   
         } catch (IOException e) {  
   
         }  
   
     }  
   
 }

用另外一種寫法試了下，也是不行，複製過去的文件大小是相同的，用比較工具比較也沒問題。

[java]view plaincopy 
       
 package com.test;<BR>
 <BR>

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。