轉載：http://zhidao.baidu.com/question/35054792.html
Eclipse插件的安裝有兩種方法
1、在eclipse的主目錄（ECLIPSE_HOME，比如在我的機器上安裝的目錄是：D:\JavaDev\3.1）有一個plugins的目錄，這種方法的插件安裝非常簡單，只要將插件copy到這個目錄下就可以了。比如我有一個weblogic的插件（bea站點上可以下載），解壓縮之后得到得到一個目錄：【com.bea.eclipse.weblogic_1.1.1】，我就將這個目錄直接放到%ECLIPSE_HOME%\plugins目錄下，重新啟動eclipse之后就看到Run->“Start Weblogic”的菜單。安裝之后，weblogic插件的全路徑為：D:\JavaDev\3.1\plugins\com.bea.eclipse.weblogic_1.1.1]
2、在eclipse目錄（ECLIPSE_HOME）下創建一個links目錄，然后將你自己的插件放在你想放的任何地方，這個時候你放插件的目錄我稱她為插件目錄（PLUGIN_HOME），然后在你的%ECLIPSE_HOME%\links\目錄下創建一個link文件，比如我要安裝一個vss插件，我就在我的links目錄下創建了：VSS_1.6.1.link文件。而這個VSS_1.6.1.link文件則是指向的我的插件目錄（PLUGIN_HOME，比如在我的機器上插件目錄為D:\JavaDev\plugins）。VSS_1.6.1.link文件的內容是：
path=D:\\JavaDev\\plugins\\vssplugin_1.6.1
第二種安裝插件的時候需要注意，如果你是一個單獨的jar文件，則最好在link文件指定的目錄下創建這樣級別的目錄：eclipse\plugins\xxx.xxx（插件名稱和版本號），然后將jar文件放在這個目錄下即可。比如vss插件在我的機器上的目錄是D:\JavaDev\plugins\vssplugin_1.6.1\eclipse\plugins\org.vssplugin_1.6.1，下有一個文件：vssplugin.jar
兩種方法的插件安裝之后需要重新啟動eclipse才能看到插件。如果某一個插件已經安裝了想要重新安裝，只要將文件替換或者修改link文件的路徑即可。如果發現認不到插件，可能是你的插件不支持你的當前eclipse版本，請檢查。也有可能是系統配置引起的，我出現過一次，我的解決方法是將ECLIPSE_HOME下的configuration目錄下的所有文件刪除，剩下config.ini文件。
13.Eclipse插件使用links目錄的用法：
假設把插件安裝在d:\myplugin目錄中，則myplugin的目錄結構一定要是這樣的：
d:\\myplugin\\eclipse\\plugins\\插件 及 d:\\myplugin\\eclipse\\features\\插件
例如安裝EclipseME插件到d:\myplugin目錄中，則目錄結構
d:\\myplugin\\eclipse\\plugins\\eclipseme_0.4.5。
再假設eclipse安裝在d:\eclipse目錄中，則在eclipse目錄中創建名稱為links的目錄，在links目
錄中建立一個link文件，比如myplugin.link，該文件內容為path=d:\\myplugin。
啟動eclipse，插件即安裝上了，如果想暫時不啟動插件，只需把myplugin.link文件刪除即可。
補充說明：
1. 插件可以分別安裝在多個自定義的目錄中。
2. 一個自定義目錄可以安裝多個插件。
3. link文件的文件名及擴展名可以取任意名稱，比如myplugin.txt，goodplugin都可以。
4. link文件可以有多行path=插件目錄，對應多個自定義插件目錄，每一行的path參數都將生效。
5. 在links目錄也可以有多個link文件，每個link文件中的path參數都將生效。
6. 插件目錄可以使用相對路徑，如果我們把myplugin目錄創建在eclipse安裝目錄中，如上例中的
d:\eclipse目錄中，則只需設置path=myplugin即可。
posted @
2009-02-18 21:36 jiafang83 閱讀(136) |
評論 (0) |
編輯 收藏
http://hi.baidu.com/menglinxi%5Fa/blog/item/cf492e4532f85821cffca383.html
1. 介紹
1）DOM(JAXP Crimson解析器)
DOM是用與平臺和語言無關的方式表示XML文檔的官方W3C標準。DOM是以層次結構組織的節點或信息片斷的集合。這個層次結構允許開發人員在樹中尋找特定信息。分析該結構通常需要加載整個文檔和構造層次結構，然后才能做任何工作。由于它是基于信息層次的，因而DOM被認為是基于樹或基于對象的。DOM以及廣義的基于樹的處理具有幾個優點。首先，由于樹在內存中是持久的，因此可以修改它以便應用程序能對數據和結構作出更改。它還可以在任何時候在樹中上下導航，而不是像SAX那樣是一次性的處理。DOM使用起來也要簡單得多。
2）SAX
SAX處理的優點非常類似于流媒體的優點。分析能夠立即開始，而不是等待所有的數據被處理。而且，由于應用程序只是在讀取數據時檢查數據，因此不需要將數據存儲在內存中。這對于大型文檔來說是個巨大的優點。事實上，應用程序甚至不必解析整個文檔；它可以在某個條件得到滿足時停止解析。一般來說，SAX還比它的替代者DOM快許多。
選擇DOM還是選擇SAX？ 對于需要自己編寫代碼來處理XML文檔的開發人員來說， 選擇DOM還是SAX解析模型是一個非常重要的設計決策。 DOM采用建立樹形結構的方式訪問XML文檔，而SAX采用的事件模型。
DOM解析器把XML文檔轉化為一個包含其內容的樹，并可以對樹進行遍歷。用DOM解析模型的優點是編程容易，開發人員只需要調用建樹的指令，然后利用navigation APIs訪問所需的樹節點來完成任務。可以很容易的添加和修改樹中的元素。然而由于使用DOM解析器的時候需要處理整個XML文檔，所以對性能和內存的要求比較高，尤其是遇到很大的XML文件的時候。由于它的遍歷能力，DOM解析器常用于XML文檔需要頻繁的改變的服務中。
SAX解析器采用了基于事件的模型，它在解析XML文檔的時候可以觸發一系列的事件，當發現給定的tag的時候，它可以激活一個回調方法，告訴該方法制定的標簽已經找到。SAX對內存的要求通常會比較低，因為它讓開發人員自己來決定所要處理的tag。特別是當開發人員只需要處理文檔中所包含的部分數據時，SAX這種擴展能力得到了更好的體現。但用SAX解析器的時候編碼工作會比較困難，而且很難同時訪問同一個文檔中的多處不同數據。
3）JDOM http://www.jdom.org/
JDOM的目的是成為Java特定文檔模型，它簡化與XML的交互并且比使用DOM實現更快。由于是第一個Java特定模型，JDOM一直得到大力推廣和促進。正在考慮通過“Java規范請求JSR-102”將它最終用作“Java標準擴展”。從2000年初就已經開始了JDOM開發。
JDOM與DOM主要有兩方面不同。首先，JDOM僅使用具體類而不使用接口。這在某些方面簡化了API，但是也限制了靈活性。第二，API大量使用了Collections類，簡化了那些已經熟悉這些類的Java開發者的使用。
JDOM文檔聲明其目的是“使用20%(或更少)的精力解決80%(或更多)Java/XML問題”(根據學習曲線假定為20%)。JDOM對于大多數Java/XML應用程序來說當然是有用的，并且大多數開發者發現API比DOM容易理解得多。JDOM還包括對程序行為的相當廣泛檢查以防止用戶做任何在XML中無意義的事。然而，它仍需要您充分理解XML以便做一些超出基本的工作(或者甚至理解某些情況下的錯誤)。這也許是比學習DOM或JDOM接口都更有意義的工作。
JDOM自身不包含解析器。它通常使用SAX2解析器來解析和驗證輸入XML文檔(盡管它還可以將以前構造的DOM表示作為輸入)。它包含一些轉換器以將JDOM表示輸出成SAX2事件流、DOM模型或XML文本文檔。JDOM是在Apache許可證變體下發布的開放源碼。
4）DOM4J http://dom4j.sourceforge.net/
雖然DOM4J代表了完全獨立的開發結果，但最初，它是JDOM的一種智能分支。它合并了許多超出基本XML文檔表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文檔或流化文檔的基于事件的處理。它還提供了構建文檔表示的選項，它通過DOM4J API和標準DOM接口具有并行訪問功能。從2000下半年開始，它就一直處于開發之中。
為支持所有這些功能，DOM4J使用接口和抽象基本類方法。DOM4J大量使用了API中的Collections類，但是在許多情況下，它還提供一些替代方法以允許更好的性能或更直接的編碼方法。直接好處是，雖然DOM4J付出了更復雜的API的代價，但是它提供了比JDOM大得多的靈活性。
在添加靈活性、XPath集成和對大文檔處理的目標時，DOM4J的目標與JDOM是一樣的：針對Java開發者的易用性和直觀操作。它還致力于成為比JDOM更完整的解決方案，實現在本質上處理所有Java/XML問題的目標。在完成該目標時，它比JDOM更少強調防止不正確的應用程序行為。
DOM4J是一個非常非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟件。如今你可以看到越來越多的Java軟件都在使用DOM4J來讀寫XML，特別值得一提的是連Sun的JAXM也在用DOM4J。
2.. 比較
1）DOM4J性能最好，連Sun的JAXM也在用DOM4J。目前許多開源項目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J來讀取XML配置文件。如果不考慮可移植性，那就采用DOM4J.
2）JDOM和DOM在性能測試時表現不佳，在測試10M文檔時內存溢出。在小文檔情況下還值得考慮使用DOM和JDOM。雖然JDOM的開發者已經說明他們期望在正式發行版前專注性能問題，但是從性能觀點來看，它確實沒有值得推薦之處。另外，DOM仍是一個非常好的選擇。DOM實現廣泛應用于多種編程語言。它還是許多其它與XML相關的標準的基礎，因為它正式獲得W3C推薦(與基于非標準的Java模型相對)，所以在某些類型的項目中可能也需要它(如在JavaScript中使用DOM)。
3）SAX表現較好，這要依賴于它特定的解析方式－事件驅動。一個SAX檢測即將到來的XML流，但并沒有載入到內存(當然當XML流被讀入時，會有部分文檔暫時隱藏在內存中)。
3. 四種xml操作方式的基本使用方法
xml文件：
<?xml version="1.0" encoding="utf-8" ?>
<Result>
<VALUE>
<NO DATE="2005">A1</NO>
<ADDR>GZ</ADDR>
</VALUE>
<VALUE>
<NO DATE="2004">A2</NO>
<ADDR>XG</ADDR>
</VALUE>
</Result>
1）DOM
import java.io.*;
import java.util.*;
import org.w3c.dom.*;
import javax.xml.parsers.*;
public class MyXMLReader{
public static void main(String arge[]){
long lasting =System.currentTimeMillis();
try{
File f=new File("data_10k.xml");
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc = builder.parse(f);
NodeList nl = doc.getElementsByTagName("VALUE");
for (int i=0;i＜nl.getLength();i++){
System.out.print("車牌號碼:" + doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
System.out.println("車主地址:" + doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
}
}catch(Exception e){
e.printStackTrace();
}
2）SAX
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
public class MyXMLReader extends DefaultHandler {
java.util.Stack tags = new java.util.Stack();
public MyXMLReader() {
super();
}
public static void main(String args[]) {
long lasting = System.currentTimeMillis();
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("data_10k.xml"), reader);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("運行時間：" + (System.currentTimeMillis() - lasting) + "毫秒");}
public void characters(char ch[], int start, int length) throws SAXException {
String tag = (String) tags.peek();
if (tag.equals("NO")) {
System.out.print("車牌號碼：" + new String(ch, start, length));
}
if (tag.equals("ADDR")) {
System.out.println("地址:" + new String(ch, start, length));
}
}
public void startElement(String uri,String localName,String qName,Attributes attrs) {
tags.push(qName);}
}
3） JDOM
import java.io.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;
public class MyXMLReader {
public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(new File("data_10k.xml"));
Element foo = doc.getRootElement();
List allChildren = foo.getChildren();
for(int i=0;i＜allChildren.size();i++) {
System.out.print("車牌號碼:" + ((Element)allChildren.get(i)).getChild("NO").getText());
System.out.println("車主地址:" + ((Element)allChildren.get(i)).getChild("ADDR").getText());
}
} catch (Exception e) {
e.printStackTrace();
}
}
4）DOM4J
import java.io.*;
import java.util.*;
import org.dom4j.*;
import org.dom4j.io.*;
public class MyXMLReader {
public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
File f = new File("data_10k.xml");
SAXReader reader = new SAXReader();
Document doc = reader.read(f);
Element root = doc.getRootElement();
Element foo;
for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {
foo = (Element) i.next();
System.out.print("車牌號碼:" + foo.elementText("NO"));
System.out.println("車主地址:" + foo.elementText("ADDR"));
}
} catch (Exception e) {
e.printStackTrace();
}
}
posted @
2009-02-18 21:27 jiafang83 閱讀(338) |
評論 (1) |
編輯 收藏
http://hi.baidu.com/lc2tp/blog/item/477c3601aac1ca011c9583dc.html
要使用dom4j讀寫XML文檔,需要先下載dom4j包,dom4j官方網站在 http://www.dom4j.org/
目前最新dom4j包下載地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip
解開后有兩個包,僅操作XML文檔的話把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的話還需要加入包jaxen-1.1-beta-7.jar.
以下是相關操作:
一.Document對象相關
1.讀取XML文件,獲得document對象.
SAXReader reader = new SAXReader();
Document document = reader.read(new File("input.xml"));
2.解析XML形式的文本,得到document對象.
String text = "<members></members>";
Document document = DocumentHelper.parseText(text);
3.主動創建document對象.
Document document = DocumentHelper.createDocument();
Element root = document.addElement("members");// 創建根節點
二.節點相關
1.獲取文檔的根節點.
Element rootElm = document.getRootElement();
2.取得某節點的單個子節點.
Element memberElm=root.element("member");// "member"是節點名
3.取得節點的文字
String text=memberElm.getText();
也可以用:
String text=root.elementText("name");這個是取得根節點下的name字節點的文字.
4.取得某節點下名為"member"的所有字節點并進行遍歷.
List nodes = rootElm.elements("member");
for (Iterator it = nodes.iterator(); it.hasNext();) {
Element elm = (Element) it.next();
// do something
}
5.對某節點下的所有子節點進行遍歷.
for(Iterator it=root.elementIterator();it.hasNext();){
Element element = (Element) it.next();
// do something
}
6.在某節點下添加子節點.
Element ageElm = newMemberElm.addElement("age");
7.設置節點文字.
ageElm.setText("29");
8.刪除某節點.
parentElm.remove(childElm);// childElm是待刪除的節點,parentElm是其父節點
三.屬性相關.
1.取得某節點下的某屬性
Element root=document.getRootElement();
Attribute attribute=root.attribute("size");// 屬性名name
2.取得屬性的文字
String text=attribute.getText();
也可以用:
String text2=root.element("name").attributeValue("firstname");這個是取得根節點下name字節點的屬性firstname的值.
3.遍歷某節點的所有屬性
Element root=document.getRootElement();
for(Iterator it=root.attributeIterator();it.hasNext();){
Attribute attribute = (Attribute) it.next();
String text=attribute.getText();
System.out.println(text);
}
4.設置某節點的屬性和文字.
newMemberElm.addAttribute("name", "sitinspring");
5.設置屬性的文字
Attribute attribute=root.attribute("name");
attribute.setText("sitinspring");
6.刪除某屬性
Attribute attribute=root.attribute("size");// 屬性名name
root.remove(attribute);
四.將文檔寫入XML文件.
1.文檔中全為英文,不設置編碼,直接寫入的形式.
XMLWriter writer = new XMLWriter(new FileWriter("output.xml"));
writer.write(document);
writer.close();
2.文檔中含有中文,設置編碼格式寫入的形式.
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("GBK"); // 指定XML編碼
XMLWriter writer = new XMLWriter(new FileWriter("output.xml"),format);
writer.write(document);
writer.close();
五.字符串與XML的轉換
1.將字符串轉化為XML
String text = "<members> <member>sitinspring</member> </members>";
Document document = DocumentHelper.parseText(text);
2.將文檔或節點的XML轉化為字符串.
SAXReader reader = new SAXReader();
Document document = reader.read(new File("input.xml"));
Element root=document.getRootElement();
String docXmlText=document.asXML();
String rootXmlText=root.asXML();
Element memberElm=root.element("member");
String memberXmlText=memberElm.asXML();
六.使用XPath快速找到節點.
讀取的XML文檔示例
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>MemberManagement</name>
<comment></comment>
<projects>
<project>PRJ1</project>
<project>PRJ2</project>
<project>PRJ3</project>
<project>PRJ4</project>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>
使用XPath快速找到節點project.
public static void main(String[] args){
SAXReader reader = new SAXReader();
try{
Document doc = reader.read(new File("sample.xml"));
List projects=doc.selectNodes("/projectDescription/projects/project");
Iterator it=projects.iterator();
while(it.hasNext()){
Element elm=(Element)it.next();
System.out.println(elm.getText());
}
}
catch(Exception ex){
ex.printStackTrace();
}
}
posted @
2009-02-18 21:25 jiafang83 閱讀(1027) |
評論 (1) |
編輯 收藏
轉載：
http://hi.baidu.com/flyx100/blog/item/ca403e2f8d73233f1f3089a7.html
Eclipse的編輯功能非常強大，掌握了Eclipse快捷鍵功能，能夠大大提高開發效率。Eclipse中有如下一些和編輯相關的快捷鍵。
1. 【ALT+/】
此快捷鍵為用戶編輯的好幫手，能為用戶提供內容的輔助，不要為記不全方法和屬性名稱犯愁，當記不全類、方法和屬性的名字時，多體驗一下【ALT+/】快捷鍵帶來的好處吧。
2. 【Ctrl+O】
顯示類中方法和屬性的大綱，能快速定位類的方法和屬性，在查找Bug時非常有用。
3. 【Ctrl+/】
快速添加注釋，能為光標所在行或所選定行快速添加注釋或取消注釋，在調試的時候可能總會需要注釋一些東西或取消注釋，現在好了，不需要每行進行重復的注釋。
4. 【Ctrl+D】
刪除當前行，這也是筆者的最愛之一，不用為刪除一行而按那么多次的刪除鍵。
5. 【Ctrl+M】
窗口最大化和還原，用戶在窗口中進行操作時，總會覺得當前窗口小（尤其在編寫代碼時），現在好了，試試【Ctrl+M】快捷鍵。
查看和定位快捷鍵
在程序中，迅速定位代碼的位置，快速找到Bug的所在，是非常不容易的事，Eclipse提供了強大的查找功能，可以利用如下的快捷鍵幫助完成查找定位的工作。
1. 【Ctrl+K】、【Ctrl++Shift+K】
快速向下和向上查找選定的內容，從此不再需要用鼠標單擊查找對話框了。
2. 【Ctrl+Shift+T】
查找工作空間（Workspace）構建路徑中的可找到Java類文件，不要為找不到類而痛苦，而且可以使用“*”、“？”等通配符。
3. 【Ctrl+Shift+R】
和【Ctrl+Shift+T】對應，查找工作空間（Workspace）中的所有文件（包括Java文件），也可以使用通配符。
4. 【Ctrl+Shift+G】
查找類、方法和屬性的引用。這是一個非常實用的快捷鍵，例如要修改引用某個方法的代碼，可以通過【Ctrl+Shift+G】快捷鍵迅速定位所有引用此方法的位置。
5. 【Ctrl+Shift+O】
快速生成import，當從網上拷貝一段程序后，不知道如何import進所調用的類，試試【Ctrl+Shift+O】快捷鍵，一定會有驚喜。
6. 【Ctrl+Shift+F】
格式化代碼，書寫格式規范的代碼是每一個程序員的必修之課，當看見某段代碼極不順眼時，選定后按【Ctrl+Shift+F】快捷鍵可以格式化這段代碼，如果不選定代碼則默認格式化當前文件（Java文件）。
7. 【ALT+Shift+W】
查找當前文件所在項目中的路徑，可以快速定位瀏覽器視圖的位置，如果想查找某個文件所在的包時，此快捷鍵非常有用（特別在比較大的項目中）。
8. 【Ctrl+L】
定位到當前編輯器的某一行，對非Java文件也有效。
9. 【Alt+←】、【Alt+→】
后退歷史記錄和前進歷史記錄，在跟蹤代碼時非常有用，用戶可能查找了幾個有關聯的地方，但可能記不清楚了，可以通過這兩個快捷鍵定位查找的順序。
10. 【F3】
快速定位光標位置的某個類、方法和屬性。
11. 【F4】
顯示類的繼承關系，并打開類繼承視圖。
調試快捷鍵
Eclipse中有如下一些和運行調試相關的快捷鍵。
1. 【Ctrl+Shift+B】：在當前行設置斷點或取消設置的斷點。
2. 【F11】：調試最后一次執行的程序。
3. 【Ctrl+F11】：運行最后一次執行的程序。
4. 【F5】：跟蹤到方法中，當程序執行到某方法時，可以按【F5】鍵跟蹤到方法中。
5. 【F6】：單步執行程序。
6. 【F7】：執行完方法，返回到調用此方法的后一條語句。
7. 【F8】：繼續執行，到下一個斷點或程序結束。
常用編輯器快捷鍵
通常文本編輯器都提供了一些和編輯相關的快捷鍵，在Eclipse中也可以通過這些快捷鍵進行文本編輯。
1. 【Ctrl+C】：復制。
2. 【Ctrl+X】：剪切。
3. 【Ctrl+V】：粘貼。
4. 【Ctrl+S】：保存文件。
5. 【Ctrl+Z】：撤銷。
6. 【Ctrl+Y】：重復。
7. 【Ctrl+F】：查找。
其他快捷鍵
Eclipse中還有很多快捷鍵，無法一一列舉，可以通過幫助文檔找到它們的使用方式，另外還有幾個常用的快捷鍵如下。
1. 【Ctrl+F6】：切換到下一個編輯器。
2. 【Ctrl+Shift+F6】：切換到上一個編輯器。
3. 【Ctrl+F7】：切換到下一個視圖。
4. 【Ctrl+Shift+F7】：切換到上一個視圖。
5. 【Ctrl+F8】：切換到下一個透視圖。
6. 【Ctrl+Shift+F8】：切換到上一個透視圖。
Eclipse中快捷鍵比較多，可以通過幫助文檔找到所有快捷鍵的使用，但要掌握所有快捷鍵的使用是不可能的，也沒有必要，如果花點時間熟悉本節列舉的快捷鍵，
--------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------
1幾個最重要的快捷鍵
代碼助手:Ctrl+Space（簡體中文操作系統是Alt+/）
快速修正：Ctrl+1
單詞補全：Alt+/
打開外部Java文檔：Shift+F2
顯示搜索對話框：Ctrl+H
快速Outline：Ctrl+O
打開資源：Ctrl+Shift+R
打開類型：Ctrl+Shift+T
顯示重構菜單：Alt+Shift+T
上一個/下一個光標的位置：Alt+Left/Right
上一個/下一個成員（成員對象或成員函數）：Ctrl+Shift+Up/Down
選中閉合元素：Alt+Shift+Up/Down/Left/Right
刪除行：Ctrl+D
在當前行上插入一行：Ctrl+Shift+Enter
在當前行下插入一行： Shift+Enter
上下移動選中的行：Alt+Up/Down
組織導入：Ctrl+Shift+O
2 定位
2.1行內定位
行末/行首：End/Home
前一個/后一個單詞：Ctrl+Right/Left
2.2文件內定位
跳到某行：Ctrl+L
上下滾屏：Ctrl+Up/Down
上一個/下一個成員（成員對象或成員函數）：Ctrl+Shift+Up/Down
快速Outline：Ctrl+O
2.3跨文件定位
打開聲明：F3
打開資源：Ctrl+Shift+R
打開類型：Ctrl+Shift+T
在workspace中搜索選中元素的聲明：Ctrl+G
在workspace中搜索選中的文本：Ctrl+Alt+G
在workspace中搜索選中元素的引用：Ctrl+Shift+G
打開調用層次結構：Ctrl+Alt+H
快速層次結構：Ctrl+T
反悔：Ctrl+Z
2.4其它
上一個/下一個光標所在位置：Alt+Left/Right
上一個編輯的位置：Ctrl+Q
3 選中
3.1行內選中
選中到行末/行首：Shift+End/Home
選中上一個/下一個單詞：Ctrl+Shift+Left/Right
3.2文件內選中
選中閉合元素：Alt+Shift+Up
恢復到上一個選中：Alt+Shift+Down
選中下一個/上一個元素：Alt+Shift+Right/Left
4 定位/選中/操作同時
刪除行：Ctrl+D
刪除下一個/上一個單詞：Ctrl+Delete/Backspace
刪除到行末：Ctrl+Shift+Delete
在當前行上插入一行：Ctrl+Shift+Enter
在當前行下插入一行： Shift+Enter
上下移動選中的行：Alt+Up/Down
拷貝選中的行：Ctrl+Alt+Up/Down
5其它的代碼編輯類快捷鍵
保存：Ctrl+S
保存所有：Ctrl+Shift+S
下一個命中的項（搜索之后）：Ctrl+.
注釋：Ctrl+/
添加導入：Ctrl+Shift+M
顯示快捷鍵幫助：Ctrl+Shift+L
變為大/小寫：Ctrl+Shift+X/Y
6 重構
顯示重構菜單：Alt+Shift+T
重構-改變方法簽名：Alt+Shift+C
重構-移動：Alt+Shift+V
重構-重命名：Alt+Shift+R
7 編輯器、視圖、透視圖切換
下一個編輯器：Ctrl+F6
下一個視圖：Ctrl+F7
下一個透視圖：Ctrl+F8
最大化當前視圖或編輯器：Ctrl+M
激活編輯器：F12
8 Debug
F5：Step Into（debug）
F6：Step over（debug）
F7：Step return（debug）
F8：Resume（debug）
F11：debug上一個應用（debug）
9 Up/Down/Right/Left類快捷鍵
Ctrl
前一個/后一個單詞：Ctrl+Right/Left
上下滾屏：Ctrl+Up/Down
Alt
上一個/下一個光標的位置：Alt+Left/Right
上下移動選中的行：Alt+Up/Down
Shift
選中上一個/下一個字符：Shift+Left/Right
選中上一行/下一行（從當前光標位置開始）：Shift+Up/Down
Ctrl+Shift
上一個/下一個成員（成員對象或成員函數）：Ctrl+Shift+Up/Down
選中上一個/下一個單詞：Ctrl+Shift+Left/Right
Alt+Shift
選中閉合元素：Alt+Shift+Up
恢復到上一個選中：Alt+Shift+Down
選中下一個/上一個元素：Alt+Shift+Right/Left
拷貝選中的行：Ctrl+Alt+Up/Down
Ctrl+Alt
拷貝選中的行：Ctrl+Alt+Up/Down
10 F類快捷鍵
F2：顯示提示/重命名
F3：打開選中元素的聲明
F4：打開選中元素的類型繼承結構
F5：刷新
F5：Step Into（debug）
F6：Step over（debug）
F7：Step return（debug）
F8：Resume（debug）
F11：debug上一個應用（debug）
F12：激活編輯器
================================================================
================================================================
MyEclipse使用技巧和快捷鍵2008-01-23 09:22Eclipse本身很快的，但是加上了myeclipse后，就狂占內存，而且速度狂慢，那如何讓Eclipse拖著myeclipse狂飚呢？這里提供一個技巧：取消自動validation
validation有一堆，什么xml、jsp、jsf、js等等，我們沒有必要全部都去自動校驗一下，只是需要的時候才會手工校驗一下，速度立馬提升好幾個檔次！
取消方法： windows-->perferences-->myeclipse-->validation
除開Manual下面的復選框全部選中之外，其他全部不選
手工驗證方法：
在要驗證的文件上，單擊鼠標右鍵-->myeclipse-->run validation
程序代碼自動排版：Ctrl+Shift+F，會自動把代碼進行格式化的排版，非常方便
快速執行程序：Ctrl + F11第一次執行時，它會詢問您執行模式，設置好后，以后只要按這個熱鍵，它就會快速執行。
Ctrl+Shift+/ 加上段注釋/**/
Ctrl+Shift+\ 取消段注釋/**/
Ctrl+/ 加上行注釋或取消行注釋
自動匯入所需要的類別：Ctrl+Shift+M Ctrl+Shift+O 好象使用Ctrl+Shift+O 也可以
按new Remote Site,Name填 svn , URL填http://subclipse.tigris.org/update,一直next到finished為止
MyEclipse 快捷鍵
（1）Ctrl+M切換窗口的大小
（2）Ctrl+Q跳到最后一次的編輯處
（3）F2當鼠標放在一個標記處出現Tooltip時候按F2則把鼠標移開時Tooltip還會顯示即Show Tooltip Description。
F3跳到聲明或定義的地方。
F5單步調試進入函數內部。
F6單步調試不進入函數內部，如果裝了金山詞霸2006則要把“取詞開關”的快捷鍵改成其他的。
F7由函數內部返回到調用處。
F8一直執行到下一個斷點。
（4）Ctrl+Pg~對于XML文件是切換代碼和圖示窗口
（5）Ctrl+Alt+I看Java文件中變量的相關信息
（6）Ctrl+PgUp對于代碼窗口是打開“Show List”下拉框，在此下拉框里顯示有最近曾打開的文件
（7）Ctrl+/ 在代碼窗口中是這種//~注釋。
Ctrl+Shift+/ 在代碼窗口中是這種/*~*/注釋，在JSP文件窗口中是<!--~-->。
（8）Alt+Shift+O(或點擊工具欄中的Toggle Mark Occurrences按鈕) 當點擊某個標記時可使本頁面中其他地方的此標記黃色凸顯，并且窗口的右邊框會出現白色的方塊，點擊此方塊會跳到此標記處。
（9）右擊窗口的左邊框即加斷點的地方選Show Line Numbers可以加行號。
（10）Ctrl+I格式化激活的元素Format Active Elements。
Ctrl+Shift+F格式化文件Format Document。
（11）Ctrl+S保存當前文件。
Ctrl+Shift+S保存所有未保存的文件。
（12）Ctrl+Shift+M(先把光標放在需導入包的類名上) 作用是加Import語句。
Ctrl+Shift+O作用是缺少的Import語句被加入，多余的Import語句被刪除。
（13）Ctrl+Space提示鍵入內容即Content Assist，此時要將輸入法中Chinese(Simplified)IME-Ime/Nonlme Toggle的快捷鍵（用于切換英文和其他文字）改成其他的。
Ctrl+Shift+Space提示信息即Context Information。
（14）雙擊窗口的左邊框可以加斷點。
（15）Ctrl+D刪除當前行
posted @
2008-12-10 14:30 jiafang83 閱讀(4784) |
評論 (0) |
編輯 收藏
轉載：
http://join-18.javaeye.com/blog/183051
1.介紹
1）DOM（JAXP Crimson解析器）
DOM是用與平臺和語言無關的方式表示XML文檔的官方W3C標準。DOM是以層次結構組織的節點或信息片斷的集合。這個層次結構允許開發人員在樹中尋找特定信息。分析該結構通常需要加載整個文檔和構造層次結構，然后才能做任何工作。由于它是基于信息層次的，因而DOM被認為是基于樹或基于對象的。DOM以及廣義的基于樹的處理具有幾個優點。首先，由于樹在內存中是持久的，因此可以修改它以便應用程序能對數據和結構作出更改。它還可以在任何時候在樹中上下導航，而不是像SAX那樣是一次性的處理。DOM使用起來也要簡單得多。
2）SAX
SAX處理的優點非常類似于流媒體的優點。分析能夠立即開始，而不是等待所有的數據被處理。而且，由于應用程序只是在讀取數據時檢查數據，因此不需要將數據存儲在內存中。這對于大型文檔來說是個巨大的優點。事實上，應用程序甚至不必解析整個文檔；它可以在某個條件得到滿足時停止解析。一般來說，SAX還比它的替代者DOM快許多。
選擇DOM還是選擇SAX？ 對于需要自己編寫代碼來處理XML文檔的開發人員來說， 選擇DOM還是SAX解析模型是一個非常重要的設計決策。 DOM采用建立樹形結構的方式訪問XML文檔，而SAX采用的事件模型。
DOM解析器把XML文檔轉化為一個包含其內容的樹，并可以對樹進行遍歷。用DOM解析模型的優點是編程容易，開發人員只需要調用建樹的指令，然后利用navigation APIs訪問所需的樹節點來完成任務。可以很容易的添加和修改樹中的元素。然而由于使用DOM解析器的時候需要處理整個XML文檔，所以對性能和內存的要求比較高，尤其是遇到很大的XML文件的時候。由于它的遍歷能力，DOM解析器常用于XML文檔需要頻繁的改變的服務中。
SAX解析器采用了基于事件的模型，它在解析XML文檔的時候可以觸發一系列的事件，當發現給定的tag的時候，它可以激活一個回調方法，告訴該方法制定的標簽已經找到。SAX對內存的要求通常會比較低，因為它讓開發人員自己來決定所要處理的tag.特別是當開發人員只需要處理文檔中所包含的部分數據時，SAX這種擴展能力得到了更好的體現。但用SAX解析器的時候編碼工作會比較困難，而且很難同時訪問同一個文檔中的多處不同數據。
3）JDOM http://www.jdom.org
JDOM的目的是成為Java特定文檔模型，它簡化與XML的交互并且比使用DOM實現更快。由于是第一個Java特定模型，JDOM一直得到大力推廣和促進。正在考慮通過“Java規范請求JSR-102”將它最終用作“Java標準擴展”。從2000年初就已經開始了JDOM開發。
JDOM與DOM主要有兩方面不同。首先，JDOM僅使用具體類而不使用接口。這在某些方面簡化了API，但是也限制了靈活性。第二，API大量使用了Collections類，簡化了那些已經熟悉這些類的Java開發者的使用。
JDOM文檔聲明其目的是“使用20%（或更少）的精力解決80%（或更多）Java/XML問題”（根據學習曲線假定為20%）。JDOM對于大多數Java/XML應用程序來說當然是有用的，并且大多數開發者發現API比DOM容易理解得多。JDOM還包括對程序行為的相當廣泛檢查以防止用戶做任何在XML中無意義的事。然而，它仍需要您充分理解XML以便做一些超出基本的工作（或者甚至理解某些情況下的錯誤）。這也許是比學習DOM或JDOM接口都更有意義的工作。
JDOM自身不包含解析器。它通常使用SAX2解析器來解析和驗證輸入XML文檔（盡管它還可以將以前構造的DOM表示作為輸入）。它包含一些轉換器以將JDOM表示輸出成SAX2事件流、DOM模型或XML文本文檔。JDOM是在Apache許可證變體下發布的開放源碼。
4）DOM4J http://dom4j.sourceforge.net
雖然DOM4J代表了完全獨立的開發結果，但最初，它是JDOM的一種智能分支。它合并了許多超出基本XML文檔表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文檔或流化文檔的基于事件的處理。它還提供了構建文檔表示的選項，它通過DOM4J API和標準DOM接口具有并行訪問功能。從2000下半年開始，它就一直處于開發之中。
為支持所有這些功能，DOM4J使用接口和抽象基本類方法。DOM4J大量使用了API中的Collections類，但是在許多情況下，它還提供一些替代方法以允許更好的性能或更直接的編碼方法。直接好處是，雖然DOM4J付出了更復雜的API的代價，但是它提供了比JDOM大得多的靈活性。
在添加靈活性、XPath集成和對大文檔處理的目標時，DOM4J的目標與JDOM是一樣的：針對Java開發者的易用性和直觀操作。它還致力于成為比JDOM更完整的解決方案，實現在本質上處理所有Java/XML問題的目標。在完成該目標時，它比JDOM更少強調防止不正確的應用程序行為。
DOM4J是一個非常非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟件。如今你可以看到越來越多的Java軟件都在使用DOM4J來讀寫XML，特別值得一提的是連Sun的JAXM也在用DOM4J.
2、比較
1）DOM4J性能最好，連Sun的JAXM也在用DOM4J.目前許多開源項目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J來讀取XML配置文件。如果不考慮可移植性，那就采用DOM4J.
2）JDOM和DOM在性能測試時表現不佳，在測試10M文檔時內存溢出。在小文檔情況下還值得考慮使用DOM和JDOM.雖然JDOM的開發者已經說明他們期望在正式發行版前專注性能問題，但是從性能觀點來看，它確實沒有值得推薦之處。另外，DOM仍是一個非常好的選擇。DOM實現廣泛應用于多種編程語言。它還是許多其它與XML相關的標準的基礎，因為它正式獲得W3C推薦（與基于非標準的Java模型相對），所以在某些類型的項目中可能也需要它（如在JavaScript中使用DOM）。
3）SAX表現較好，這要依賴于它特定的解析方式－事件驅動。一個SAX檢測即將到來的XML流，但并沒有載入到內存（當然當XML流被讀入時，會有部分文檔暫時隱藏在內存中）。
3.四種XML操作方式的基本使用方法
xml文件：
＜?xml version="1.0" encoding="GB2312"?＞
＜RESULT＞
＜VALUE＞
＜NO＞A1234＜/NO＞
＜ADDR＞四川省XX縣XX鎮XX路X段XX號＜/ADDR＞
＜/VALUE＞
＜VALUE＞
＜NO＞B1234＜/NO＞
＜ADDR＞四川省XX市XX鄉XX村XX組＜/ADDR＞
＜/VALUE＞
＜/RESULT＞
1）DOM
import java.io.*;
import java.util.*;
import org.w3c.dom.*;
import javax.xml.parsers.*;
public class MyXMLReader{
public static void main(String arge[]){
long lasting =System.currentTimeMillis();
try{
File f=new File("data_10k.xml");
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc = builder.parse(f);
NodeList nl = doc.getElementsByTagName("VALUE");
for (int i=0;i＜nl.getLength();i++){
System.out.print("車牌號碼:" +
doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
System.out.println("車主地址:" +
doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
}
}catch(Exception e){
e.printStackTrace();
}
2）SAX
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
public class MyXMLReader extends DefaultHandler {
java.util.Stack tags = new java.util.Stack();
public MyXMLReader() {
super();
}
public static void main(String args[]) {
long lasting = System.currentTimeMillis();
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("data_10k.xml"), reader);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("運行時間：" + (System.currentTimeMillis() - lasting) + "毫秒");}
public void characters(char ch[], int start, int length) throws SAXException {
String tag = (String) tags.peek();
if (tag.equals("NO")) {
System.out.print("車牌號碼：" + new String(ch, start, length));
}
if (tag.equals("ADDR")) {
System.out.println("地址:" + new String(ch, start, length));
}
}
public void startElement(String uri,String localName,String qName,Attributes attrs) {
tags.push(qName);}
}
3）JDOM
import java.io.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;
public class MyXMLReader {
public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(new File("data_10k.xml"));
Element foo = doc.getRootElement();
List allChildren = foo.getChildren();
for(int i=0;i＜allChildren.size();i++) {
System.out.print("車牌號碼:" +
((Element)allChildren.get(i)).getChild("NO").getText());
System.out.println("車主地址:" +
((Element)allChildren.get(i)).getChild("ADDR").getText());
}
} catch (Exception e) {
e.printStackTrace();
}
}
4）DOM4J
import java.io.*;
import java.util.*;
import org.dom4j.*;
import org.dom4j.io.*;
public class MyXMLReader {
public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
File f = new File("data_10k.xml");
SAXReader reader = new SAXReader();
Document doc = reader.read(f);
Element root = doc.getRootElement();
Element foo;
for (Iterator i = root.elementIterator("VALUE"); i.hasNext() {
foo = (Element) i.next();
System.out.print("車牌號碼:" + foo.elementText("NO"));
System.out.println("車主地址:" + foo.elementText("ADDR"));
}
} catch (Exception e) {
e.printStackTrace();
}
)
posted @
2008-12-10 09:38 jiafang83 閱讀(185) |
評論 (0) |
編輯 收藏
類Object是類層次結構的根類，每一個類都使用Object作為超類，所有對象（包括數組）都實現這個類的方法。jdk1.5中，描述了該類中的11個方法
1.getClass
public final Class<? extends Object> getClass()
- 返回一個對象的運行時類。該 Class 對象是由所表示類的 static synchronized 方法鎖定的對象。
-
- 返回：
- 表示該對象的運行時類的
java.lang.Class 對象。此結果屬于類型 Class<? extends X>，其中 X 表示清除表達式中的靜態類型，該表達式調用 getClass。
2.hashCode
public int hashCode()
- 返回該對象的哈希碼值。支持該方法是為哈希表提供一些優點，例如，
java.util.Hashtable 提供的哈希表。
hashCode 的常規協定是：
- 在 Java 應用程序執行期間，在同一對象上多次調用 hashCode 方法時，必須一致地返回相同的整數，前提是對象上 equals 比較中所用的信息沒有被修改。從某一應用程序的一次執行到同一應用程序的另一次執行，該整數無需保持一致。
- 如果根據 equals(Object) 方法，兩個對象是相等的，那么在兩個對象中的每個對象上調用
hashCode 方法都必須生成相同的整數結果。
- 以下情況不 是必需的：如果根據
equals(java.lang.Object) 方法，兩個對象不相等，那么在兩個對象中的任一對象上調用 hashCode 方法必定會生成不同的整數結果。但是，程序員應該知道，為不相等的對象生成不同整數結果可以提高哈希表的性能。
實際上，由 Object 類定義的 hashCode 方法確實會針對不同的對象返回不同的整數。（這一般是通過將該對象的內部地址轉換成一個整數來實現的，但是 JavaTM 編程語言不需要這種實現技巧。）
-
- 返回：
- 此對象的一個哈希碼值。
3.equals
public boolean equals(Object obj)
- 指示某個其他對象是否與此對象“相等”。
equals 方法在非空對象引用上實現相等關系：
- 自反性：對于任何非空引用值
x，x.equals(x) 都應返回 true。
- 對稱性：對于任何非空引用值
x 和 y，當且僅當 y.equals(x) 返回 true 時，x.equals(y) 才應返回 true。
- 傳遞性：對于任何非空引用值
x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 應返回 true。
- 一致性：對于任何非空引用值
x 和 y，多次調用 x.equals(y) 始終返回 true 或始終返回 false，前提是對象上 equals 比較中所用的信息沒有被修改。
- 對于任何非空引用值
x，x.equals(null) 都應返回 false。
Object 類的 equals 方法實現對象上差別可能性最大的相等關系；即，對于任何非空引用值 x 和 y，當且僅當 x 和 y 引用同一個對象時，此方法才返回 true（x == y 具有值 true）。
注意：當此方法被重寫時，通常有必要重寫 hashCode 方法，以維護 hashCode 方法的常規協定，該協定聲明相等對象必須具有相等的哈希碼。
-
- 參數：
obj - 要與之比較的引用對象。
- 返回：
- 如果此對象與 obj 參數相同，則返回
true；否則返回 false。
4.clone
protected Object clone()
throws CloneNotSupportedException
- 創建并返回此對象的一個副本。“副本”的準確含義可能依賴于對象的類。一般來說，對于任何對象 x，如果表達式：
x.clone() != x
是正確的，則表達式：
x.clone().getClass() == x.getClass()
將為 true，但這些不是絕對條件。一般情況下是：
x.clone().equals(x)
將為 true，但這不是絕對條件。
按照慣例，返回的對象應該通過調用 super.clone 獲得。如果一個類及其所有的超類（Object 除外）都遵守此約定，則 x.clone().getClass() == x.getClass()。
按照慣例，此方法返回的對象應該獨立于該對象（正被克隆的對象）。要獲得此獨立性，在 super.clone 返回對象之前，有必要對該對象的一個或多個字段進行修改。這通常意味著要復制包含正在被克隆對象的內部“深層結構”的所有可變對象，并使用對副本的引用替換對這些對象的引用。如果一個類只包含基本字段或對不變對象的引用，那么通常不需要修改 super.clone 返回的對象中的字段。
Object 類的 clone 方法執行特定的克隆操作。首先，如果此對象的類不能實現接口 Cloneable，則會拋出 CloneNotSupportedException。注意：所有的數組都被視為實現接口 Cloneable。否則，此方法會創建此對象的類的一個新實例，并像通過分配那樣，嚴格使用此對象相應字段的內容初始化該對象的所有字段；這些字段的內容沒有被自我克隆。所以，此方法執行的是該對象的“淺表復制”，而不“深層復制”操作。
Object 類本身不實現接口 Cloneable，所以在類為 Object 的對象上調用 clone 方法將會導致在運行時拋出異常。
-
- 返回：
- 此實例的一個克隆。
- 拋出：
CloneNotSupportedException - 如果對象的類不支持 Cloneable 接口，則重寫 clone 方法的子類也會拋出此異常，以指示無法克隆某個實例。
5.toString
public String toString()
- 返回該對象的字符串表示。通常，
toString 方法會返回一個“以文本方式表示”此對象的字符串。結果應是一個簡明但易于讀懂。建議所有子類都重寫此方法。
Object 類的 toString 方法返回一個字符串，該字符串由類名（對象是該類的一個實例）、at 標記符“@”和此對象哈希碼的無符號十六進制表示組成。換句話說，該方法返回一個字符串，它的值等于：
getClass().getName() + '@' + Integer.toHexString(hashCode())
-
- 返回：
- 該對象的字符串表示形式。
6.notify
public final void notify()
- 喚醒在此對象監視器上等待的單個線程。如果所有線程都在此對象上等待，則會選擇喚醒其中一個線程。選擇是任意性的，并在對實現做出決定時發生。線程通過調用其中一個
wait 方法，在對象的監視器上等待。
直到當前的線程放棄此對象上的鎖定，才能繼續執行被喚醒的線程。被喚醒的線程將以常規方式與在該對象上主動同步的其他所有線程進行競爭；例如，喚醒的線程在作為鎖定此對象的下一個線程方面沒有可靠的特權或劣勢。
此方法只應由作為此對象監視器的所有者的線程來調用。通過以下三種方法之一，線程可以成為此對象監視器的所有者：
- 通過執行此對象的同步 (Sychronized) 實例方法。
- 通過執行在此對象上進行同步的
synchronized 語句的正文。
- 對于
Class 類型的對象，可以通過執行該類的同步靜態方法。
一次只能有一個線程擁有對象的監視器。
-
- 拋出：
IllegalMonitorStateException - 如果當前的線程不是此對象監視器的所有者。
7.notifyAll
public final void notifyAll()
- 喚醒在此對象監視器上等待的所有線程。線程通過調用其中一個
wait 方法，在對象的監視器上等待。
直到當前的線程放棄此對象上的鎖定，才能繼續執行被喚醒的線程。被喚醒的線程將以常規方式與在該對象上主動同步的其他所有線程進行競爭；例如，喚醒的線程在作為鎖定此對象的下一個線程方面沒有可靠的特權或劣勢。
此方法只應由作為此對象監視器的所有者的線程來調用。請參閱 notify 方法，了解線程能夠成為監視器所有者的方法的描述。
-
- 拋出：
IllegalMonitorStateException - 如果當前的線程不是此對象監視器的所有者。
8.finalize
protected void finalize()
throws Throwable
- 當垃圾回收器確定不存在對該對象的更多引用時，由對象的垃圾回收器調用此方法。子類重寫
finalize 方法，以配置系統資源或執行其他清除。
finalize 的常規協定是：當 JavaTM 虛擬機已確定尚未終止的任何線程無法再通過任何方法訪問此對象時，將調用此方法，除非由于準備終止的其他某個對象或類的終結操作執行了某個操作。finalize 方法可以采取任何操作，其中包括再次使此對象對其他線程可用；不過，finalize 的主要目的是在不可撤消地丟棄對象之前執行清除操作。例如，表示輸入/輸出連接的對象的 finalize 方法可執行顯式 I/O 事務，以便在永久丟棄對象之前中斷連接。
Object 類的 finalize 方法執行非特殊性操作；它僅執行一些常規返回。Object 的子類可以重寫此定義。
Java 編程語言不保證哪個線程將調用某個給定對象的 finalize 方法。但可以保證在調用 finalize 時，調用 finalize 的線程將不會持有任何用戶可見的同步鎖定。如果 finalize 方法拋出未捕獲的異常，那么該異常將被忽略，并且該對象的終結操作將終止。
在啟用某個對象的 finalize 方法后，將不會執行進一步操作，直到 Java 虛擬機再次確定尚未終止的任何線程無法再通過任何方法訪問此對象，其中包括由準備終止的其他對象或類執行的可能操作，在執行該操作時，對象可能被丟棄。
對于任何給定對象，Java 虛擬機最多只調用一次 finalize 方法。
finalize 方法拋出的任何異常都會導致此對象的終結操作停止，但可以通過其他方法忽略它。
-
- 拋出：
Throwable - 此方法拋出的 Exception
9.wait
public final void wait(long timeout)
throws InterruptedException
- 導致當前的線程等待，直到其他線程調用此對象的
notify() 方法或 notifyAll() 方法，或者超過指定的時間量。
當前的線程必須擁有此對象監視器。
此方法導致當前線程（稱之為 T）將其自身放置在對象的等待集中，然后放棄此對象上的所有同步要求。出于線程調度目的，線程 T 被禁用，且處于休眠狀態，直到發生以下四種情況之一：
- 其他某個線程調用此對象的 notify 方法，并且線程 T 碰巧被任選為被喚醒的線程。
- 其他某個線程調用此對象的 notifyAll 方法。
- 其他某個線程
中斷線程 T。
- 已經到達指定的實際時間。但是，如果 timeout 為零，則不考慮實際時間，該線程將一直等待，直到獲得通知。
然后，從對象的等待集中刪除線程 T，并重新進行線程調度。然后，該線程以常規方式與其他線程競爭，以獲得在該對象上同步的權利；一旦獲得對該對象的控制權，該對象上的所有其同步聲明都將被還原到以前的狀態 - 這就是調用 wait 方法時的情況。然后，線程 T 從 wait 方法的調用中返回。所以，從 wait 方法返回時，該對象和線程 T 的同步狀態與調用 wait 方法時的情況完全相同。
在沒有被通知、中斷或超時的情況下，線程還可以喚醒一個所謂的虛假喚醒 (spurious wakeup)。雖然這種情況在實踐中很少發生，但是應用程序必須通過以下方式防止其發生，即對應該導致該線程被提醒的條件進行測試，如果不滿足該條件，則繼續等待。換句話說，等待應總是發生在循環中，如下面的示例：
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout);
... // Perform action appropriate to condition
}
（有關這一主題的更多信息，請參閱 Doug Lea 撰寫的《Concurrent Programming in Java (Second Edition)》(Addison-Wesley, 2000) 中的第 3.2.3 節或 Joshua Bloch 撰寫的《Effective Java Programming Language Guide》(Addison-Wesley, 2001) 中的第 50 項。
如果當前線程在等待時被其他線程中斷，則會拋出 InterruptedException。在按上述形式恢復此對象的鎖定狀態時才會拋出此異常。
注意，由于 wait 方法將當前的線程放入了對象的等待集中，所以它只能解除此對象的鎖定；可以同步當前線程的任何其他對象在線程等待時仍處于鎖定狀態。
此方法只應由作為此對象監視器的所有者的線程來調用。請參閱 notify 方法，了解線程能夠成為監視器所有者的方法的描述。
- 參數：
timeout - 要等待的最長時間（以毫秒為單位）。
- 拋出：
IllegalArgumentException - 如果超時值為負。
IllegalMonitorStateException - 如果當前的線程不是此對象監視器的所有者。
InterruptedException - 如果在當前線程等待通知之前或者正在等待通知時，另一個線程中斷了當前線程。在拋出此異常時，當前線程的中斷狀態 被清除。
10.wait
public final void wait(long timeout,
int nanos)
throws InterruptedException
- 導致當前的線程等待，直到其他線程調用此對象的
notify() 方法或 notifyAll() 方法，或者其他某個線程中斷當前線程，或者已超過某個實際時間量。
此方法類似于一個參數的 wait 方法，但它允許更好地控制在放棄之前等待通知的時間量。用毫微秒度量的實際時間量可以通過以下公式計算出來：
1000000*timeout+nanos
在其他所有方面，此方法執行的操作與帶有一個參數的 wait(long) 方法相同。需要特別指出的是，wait(0, 0) 與 wait(0) 相同。
當前的線程必須擁有此對象監視器。該線程發布對此監視器的所有權，并等待下面兩個條件之一發生：
- 其他線程通過調用
notify 方法，或 notifyAll 方法通知在此對象的監視器上等待的線程醒來。
timeout 毫秒值與 nanos 毫微秒參數值之和指定的超時時間已用完。
然后，該線程等到重新獲得對監視器的所有權后才能繼續執行。
對于某一個參數的版本，實現中斷和虛假喚醒是有可能的，并且此方法應始終在循環中使用：
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout, nanos);
... // Perform action appropriate to condition
}
此方法只應由作為此對象監視器的所有者的線程來調用。請參閱 notify 方法，了解線程能夠成為監視器所有者的方法的描述。
- 參數：
timeout - 要等待的最長時間（以毫秒為單位）。
nanos - 額外時間（以毫微秒為單位，范圍是 0-999999）。
- 拋出：
IllegalArgumentException - 如果超時值是負數，或者毫微秒值不在 0-999999 范圍內。
IllegalMonitorStateException - 如果當前線程不是此對象監視器的所有者。
InterruptedException - 如果在當前線程等待通知之前或者正在等待通知時，其他線程中斷了當前線程。在拋出此異常時，當前線程的中斷狀態 被清除。
11.wait
public final void wait()
throws InterruptedException
- 導致當前的線程等待，直到其他線程調用此對象的
notify() 方法或 notifyAll() 方法。換句話說，此方法的行為就好像它僅執行 wait(0) 調用一樣。
當前的線程必須擁有此對象監視器。該線程發布對此監視器的所有權并等待，直到其他線程通過調用 notify 方法，或 notifyAll 方法通知在此對象的監視器上等待的線程醒來。然后該線程將等到重新獲得對監視器的所有權后才能繼續執行。
對于某一個參數的版本，實現中斷和虛假喚醒是可能的，而且此方法應始終在循環中使用：
synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
}
此方法只應由作為此對象監視器的所有者的線程來調用。請參閱 notify 方法，了解線程能夠成為監視器所有者的方法的描述。
- 拋出：
IllegalMonitorStateException - 如果當前的線程不是此對象監視器的所有者。
InterruptedException - 如果在當前線程等待通知之前或者正在等待通知時，另一個線程中斷了當前線程。在拋出此異常時，當前線程的中斷狀態 被清除。
-
posted @
2008-12-05 10:25 jiafang83 閱讀(8168) |
評論 (0) |
編輯 收藏 今天忽然想起這么個問題：在eclipse下運行的java程序，它們的字節碼文件跑哪去啦，怎么在項目中看不到呢？在網上查了一下，終于找到了原因所在。
原來classes文件夾所在的目錄是程序編譯輸出的路徑，只有在eclipse下的Resource透視圖下，才能顯示出來，在其它透視圖下都不能顯示。
posted @
2008-12-05 10:02 jiafang83 閱讀(3364) |
評論 (0) |
編輯 收藏
摘要: 轉載：http://download.csdn.net/source/245338
1. Jdbc的六個編程步驟
1. 注冊一個驅動
注冊驅動程序有三種方式： &nbs...
閱讀全文
posted @
2008-12-01 17:00 jiafang83 閱讀(1038) |
評論 (0) |
編輯 收藏
摘要:
轉載：http://www.builder.com.cn/2007/1211/678982.shtml
目前，國內外信息化建設已經進入基于Web應用為核心的階段， Java作為應用于網絡的最好語言，前景無限看好。然而，就算用Java建造一個不是很煩瑣的web應用，也不是件輕松的事情。概括一下，實施Java的WEB項目需要掌握的技術如下：
l &...
閱讀全文
posted @
2008-12-01 16:23 jiafang83 閱讀(196) |
評論 (0) |
編輯 收藏
摘要: 轉載：http://www.tkk7.com/rongxh7
分頁顯示一直是web開發中一大煩瑣的難題，傳統的網頁設計只在一個JSP或者ASP頁面中書寫所有關于數據庫操作的代碼，那樣做分頁可能簡單一點，但當把網站分層開發后，分頁就比較困難了，下面是我做Spring+Hibernate+Struts2項目時設計的分頁代碼，與大家分享交流。
...
閱讀全文
posted @
2008-12-01 14:08 jiafang83 閱讀(1411) |
評論 (2) |
編輯 收藏