类并不是一个通用的工具类，需要按自己的要求实现，这里只记录了Htmlparse.jar包的一些用法。仅此而已！ 
详细看这里：http://gundumw100.iteye.com/blog/704311 

Java代码  收藏代码
    1. import java.util.*;  
    2. import org.htmlparser.Node;  
    3. import org.htmlparser.NodeFilter;  
    4. import org.htmlparser.Parser;  
    5. import org.htmlparser.filters.AndFilter;  
    6. import org.htmlparser.filters.HasAttributeFilter;  
    7. import org.htmlparser.filters.NodeClassFilter;  
    8. import org.htmlparser.filters.TagNameFilter;  
    9. import org.htmlparser.tags.BodyTag;  
    10. import org.htmlparser.tags.LinkTag;  
    11. import org.htmlparser.util.NodeList;  
    12. import org.htmlparser.util.ParserException;  
    13.   
    14. /** 
    15.  * httpclient与htmlparse对网页的解析 
    16.  *  
    17.  * @author Administrator 
    18.  *  
    19.  */  
    20. public class HtmlparseUtil {  
    21.     WebHttpClient util=new WebHttpClient();  
    22.     /** 
    23.      * 获得网页中的超链接，将href和text保存在Map中：map(href,text) 
    24.      * @param url 
    25.      * @param charset 
    26.      * @return 
    27.      */  
    28.     public Map<String, String> linkGet(String url, String charset) {  
    29.         String content=util.getWebContentByGet(url,charset);  
    30.         Map<String, String> linkMap = new HashMap<String, String>();  
    31.         try {  
    32.             //开始解析  
    33.             Parser parser = Parser.createParser(content, charset);  
    34.             // 过滤出<a></a>标签  
    35.             NodeFilter linkFilter = new NodeClassFilter(LinkTag.class);  
    36.             NodeList list = parser.extractAllNodesThatMatch(linkFilter);  
    37.             Node node = null;  
    38.             for (int i = 0; i < list.size(); i++) {  
    39.                 node = list.elementAt(i);  
    40.                 // 获得网页中的链接map(href,text)  
    41.                 linkMap.put(((LinkTag) node).getLink(), this.processText(((LinkTag) node).getLinkText()));  
    42.             }  
    43.         } catch (ParserException e) {  
    44.             e.printStackTrace();  
    45.         }   
    46.         return linkMap;  
    47.     }  
    48.   
    49.     /** 
    50.      * 获得网页<body></body>标签中的内容， 保存在body中 
    51.      * @param url 
    52.      * @param charset 
    53.      * @return 
    54.      */  
    55.     public String bodyGet(String url, String charset) {  
    56.         String content=util.getWebContentByGet(url,charset);  
    57.         String body = "";  
    58.         try {  
    59.             Parser parser = Parser.createParser(content, charset);  
    60.             // 过滤<body></body>标签  
    61.             NodeFilter bodyFilter = new NodeClassFilter(BodyTag.class);  
    62.             NodeList list = parser.extractAllNodesThatMatch(bodyFilter);  
    63.             Node node = null;  
    64.             for (int i = 0; i < list.size(); i++) {  
    65.                 node = list.elementAt(i);  
    66.                 // 获得网页内容 保存在content中  
    67.                 body = ((BodyTag) node).getBody();  
    68.             }  
    69.         } catch (ParserException e) {  
    70.             e.printStackTrace();  
    71.         }  
    72.         return body;  
    73.     }  
    74.   
    75.     /** 
    76.      * 过滤出class为term的<span>元素,并获得他们的文本 
    77.      * @param url 
    78.      * @param charset 
    79.      * @return 
    80.      */  
    81.     public Map<String,String> termGet(String url, String charset) {  
    82.         String content=util.getWebContentByGet(url,charset);  
    83.           
    84.         Map<String, String> map = new HashMap<String, String>();  
    85.         try {  
    86.             //开始解析  
    87.             // 过滤出class为term的<span>元素  
    88.             Parser parser = Parser.createParser(content, charset);  
    89.             AndFilter filter =   
    90.                 new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("class","term"));  
    91.               
    92.             Node node = null;  
    93.             NodeList nodeList = parser.parse(filter);  
    94.               
    95.             for (int i = 0; i < nodeList.size(); i++) {  
    96.                 node = nodeList.elementAt(i);  
    97.                 map.put("term", node.toPlainTextString());  
    98.             }  
    99.             // 过滤出class为start-time的<span>元素  
    100.             Parser parser2 = Parser.createParser(content, charset);  
    101.             AndFilter filter2 =   
    102.                 new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("class","start-time"));  
    103.             NodeList nodeList2 = parser2.parse(filter2);  
    104.             for (int i = 0; i < nodeList2.size(); i++) {  
    105.                 node = nodeList2.elementAt(i);  
    106.                 map.put("start-time", node.toPlainTextString());  
    107.             }  
    108.             // 过滤出id为J_SingleEndTimeLabel的<span>元素  
    109.             Parser parser3 = Parser.createParser(content, charset);  
    110.             AndFilter filter3 =   
    111.                 new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("id","J_SingleEndTimeLabel"));  
    112.             NodeList nodeList3 = parser3.parse(filter3);  
    113.             for (int i = 0; i < nodeList3.size(); i++) {  
    114.                 node = nodeList3.elementAt(i);  
    115.                 map.put("end-time", node.toPlainTextString());  
    116.             }  
    117.               
    118.             // 过滤出class为box post的<div>元素  
    119.             Parser parser4 = Parser.createParser(content, charset);  
    120.             AndFilter filter4 =   
    121.                 new AndFilter(new TagNameFilter("div"),new HasAttributeFilter("class","box post"));  
    122.             NodeList nodeList4 = parser4.parse(filter4);  
    123.             for (int i = 0; i < nodeList4.size(); i++) {  
    124.                 node = nodeList4.elementAt(i);  
    125.                 String temp=node.toPlainTextString().trim();  
    126.                 temp=temp.substring(10,20).trim();  
    127.                 map.put("pre-term", temp);  
    128.             }  
    129.               
    130.             // 过滤出class为J_AwardNumber的<span>元素  
    131.             Parser parser5 = Parser.createParser(content, charset);  
    132. //          AndFilter filter5 =   
    133. //                new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("class","J_AwardNumber"));  
    134.             NodeList nodeList5 = parser5.parse(new HasAttributeFilter("class","J_AwardNumber"));  
    135.             StringBuffer buffer=new StringBuffer();  
    136.             for (int i = 0; i < nodeList5.size(); i++) {  
    137.                 node = nodeList5.elementAt(i);  
    138.                 buffer.append(","+node.toPlainTextString());  
    139.             }  
    140.             buffer.append("|");  
    141.               
    142.             // 过滤出class为blue J_AwardNumber的<span>元素  
    143.             Parser parser6 = Parser.createParser(content, charset);  
    144. //          AndFilter filter6 =   
    145. //                new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("class","blue J_AwardNumber"));  
    146.             NodeList nodeList6 = parser6.parse(new HasAttributeFilter("class","blue J_AwardNumber"));  
    147.             for (int i = 0; i < nodeList6.size(); i++) {  
    148.                 node = nodeList6.elementAt(i);  
    149.                 buffer.append(node.toPlainTextString()+",");  
    150.             }  
    151.               
    152.             map.put("numbers", buffer.toString());  
    153.         } catch (ParserException e) {  
    154.             // TODO Auto-generated catch block  
    155.             e.printStackTrace();  
    156.         }  
    157.           
    158.         return map;  
    159.     }  
    160.       
    161.     private String processText(String content){     
    162.         content=content.trim().replaceAll("&nbsp;", "");     
    163. //      content=content.replaceAll("<p>", "\n");     
    164. //      content=content.replaceAll("</TD>", "");     
    165. //      content=content.replaceAll("</div>", "");     
    166. //      content=content.replaceAll("</a>", "");     
    167. //      content=content.replaceAll("<a href=.*>", "");     
    168.         return content;     
    169.     }     
    170.       
    171.     public static void main(String[] str) {  
    172.           
    173.         String url="http://caipiao.taobao.com/lottery/order/lottery_dlt.htm?type=1";  
    174.         HtmlparseUtil util=new HtmlparseUtil();  
    175.         Map<String,String> map=util.termGet(url, "gb2312");  
    176.         System.out.println("term="+map.get("term"));//<span class="term">第<em>10074</em>期</span>  
    177.         System.out.println("start-time="+map.get("start-time"));//  
    178.         System.out.println("end-time="+map.get("end-time"));//  
    179.         System.out.println("pre-term="+map.get("pre-term"));//  
    180.         System.out.println("numbers="+map.get("numbers"));//  
    181.           
    182.         /* 
    183.         Map<String, String> linkMap = util.linkGet(url, "gb2312"); 
    184.         for (String s : linkMap.keySet()) { 
    185.             System.out.println(s + " = " + linkMap.get(s)); 
    186.             //如果是个链接，则再获取它的<body>中的内容 
    187. //          if (s.startsWith("http")) { 
    188. //              util.bodyGet(s, "gb2312"); 
    189. //          } 
    190.         } 
    191.         */  
    192.           
    193.     }  
    194.       
    195. }