java 正则表达式 过滤html标签（转）

转自：http://aguang520.iteye.com/blog/1056686#

前段时间开发的时候要读取一篇文章的简介内容（也就是前200个字符），使用了隐藏字段，可能有人就要问了，那后台也是可以截取字符的啊，那是因为编辑器里面包含了html标签，所以后台就需要处理html标签的正则表达式，前些天上网搜了下，发现有人写好的一个类，给大家共享下，不要闲小弟落伍了...

Java代码   

1. import java.util.regex.Matcher;   
2. import java.util.regex.Pattern;   
3.   
4. /**  
5.  * <p>  
6.  * Title: HTML相关的正则表达式工具类  
7.  * </p>  
8.  * <p>  
9.  * Description: 包括过滤HTML标记，转换HTML标记，替换特定HTML标记  
10.  * </p>  
11.  * <p>  
12.  * Copyright: Copyright (c) 2006  
13.  * </p>  
14.  *   
15.  * @author hejian  
16.  * @version 1.0  
17.  * @createtime 2006-10-16  
18.  */  
19.   
20. public class HtmlRegexpUtil {   
21.     private final static String regxpForHtml = "<([^>]*)>"; // 过滤所有以<开头以>结尾的标签   
22.   
23.     private final static String regxpForImgTag = "<\\s*img\\s+([^>]*)\\s*>"; // 找出IMG标签   
24.   
25.     private final static String regxpForImaTagSrcAttrib = "src=\"([^\"]+)\""; // 找出IMG标签的SRC属性   
26.   
27.     /**  
28.      *   
29.      */  
30.     public HtmlRegexpUtil() {   
31.         // TODO Auto-generated constructor stub   
32.     }   
33.   
34.     /**  
35.      *   
36.      * 基本功能：替换标记以正常显示  
37.      * <p>  
38.      *   
39.      * @param input  
40.      * @return String  
41.      */  
42.     public String replaceTag(String input) {   
43.         if (!hasSpecialChars(input)) {   
44.             return input;   
45.         }   
46.         StringBuffer filtered = new StringBuffer(input.length());   
47.         char c;   
48.         for (int i = 0; i <= input.length() - 1; i++) {   
49.             c = input.charAt(i);   
50.             switch (c) {   
51.             case '<':   
52.                 filtered.append("&lt;");   
53.                 break;   
54.             case '>':   
55.                 filtered.append("&gt;");   
56.                 break;   
57.             case '"':   
58.                 filtered.append("&quot;");   
59.                 break;   
60.             case '&':   
61.                 filtered.append("&amp;");   
62.                 break;   
63.             default:   
64.                 filtered.append(c);   
65.             }   
66.   
67.         }   
68.         return (filtered.toString());   
69.     }   
70.   
71.     /**  
72.      *   
73.      * 基本功能：判断标记是否存在  
74.      * <p>  
75.      *   
76.      * @param input  
77.      * @return boolean  
78.      */  
79.     public boolean hasSpecialChars(String input) {   
80.         boolean flag = false;   
81.         if ((input != null) && (input.length() > 0)) {   
82.             char c;   
83.             for (int i = 0; i <= input.length() - 1; i++) {   
84.                 c = input.charAt(i);   
85.                 switch (c) {   
86.                 case '>':   
87.                     flag = true;   
88.                     break;   
89.                 case '<':   
90.                     flag = true;   
91.                     break;   
92.                 case '"':   
93.                     flag = true;   
94.                     break;   
95.                 case '&':   
96.                     flag = true;   
97.                     break;   
98.                 }   
99.             }   
100.         }   
101.         return flag;   
102.     }   
103.   
104.     /**  
105.      *   
106.      * 基本功能：过滤所有以"<"开头以">"结尾的标签  
107.      * <p>  
108.      *   
109.      * @param str  
110.      * @return String  
111.      */  
112.     public static String filterHtml(String str) {   
113.         Pattern pattern = Pattern.compile(regxpForHtml);   
114.         Matcher matcher = pattern.matcher(str);   
115.         StringBuffer sb = new StringBuffer();   
116.         boolean result1 = matcher.find();   
117.         while (result1) {   
118.             matcher.appendReplacement(sb, "");   
119.             result1 = matcher.find();   
120.         }   
121.         matcher.appendTail(sb);   
122.         return sb.toString();   
123.     }   
124.   
125.     /**  
126.      *   
127.      * 基本功能：过滤指定标签  
128.      * <p>  
129.      *   
130.      * @param str  
131.      * @param tag  
132.      *            指定标签  
133.      * @return String  
134.      */  
135.     public static String fiterHtmlTag(String str, String tag) {   
136.         String regxp = "<\\s*" + tag + "\\s+([^>]*)\\s*>";   
137.         Pattern pattern = Pattern.compile(regxp);   
138.         Matcher matcher = pattern.matcher(str);   
139.         StringBuffer sb = new StringBuffer();   
140.         boolean result1 = matcher.find();   
141.         while (result1) {   
142.             matcher.appendReplacement(sb, "");   
143.             result1 = matcher.find();   
144.         }   
145.         matcher.appendTail(sb);   
146.         return sb.toString();   
147.     }   
148.   
149.     /**  
150.      *   
151.      * 基本功能：替换指定的标签  
152.      * <p>  
153.      *   
154.      * @param str  
155.      * @param beforeTag  
156.      *            要替换的标签  
157.      * @param tagAttrib  
158.      *            要替换的标签属性值  
159.      * @param startTag  
160.      *            新标签开始标记  
161.      * @param endTag  
162.      *            新标签结束标记  
163.      * @return String  
164.      * @如：替换img标签的src属性值为[img]属性值[/img]  
165.      */  
166.     public static String replaceHtmlTag(String str, String beforeTag,   
167.             String tagAttrib, String startTag, String endTag) {   
168.         String regxpForTag = "<\\s*" + beforeTag + "\\s+([^>]*)\\s*>";   
169.         String regxpForTagAttrib = tagAttrib + "=\"([^\"]+)\"";   
170.         Pattern patternForTag = Pattern.compile(regxpForTag);   
171.         Pattern patternForAttrib = Pattern.compile(regxpForTagAttrib);   
172.         Matcher matcherForTag = patternForTag.matcher(str);   
173.         StringBuffer sb = new StringBuffer();   
174.         boolean result = matcherForTag.find();   
175.         while (result) {   
176.             StringBuffer sbreplace = new StringBuffer();   
177.             Matcher matcherForAttrib = patternForAttrib.matcher(matcherForTag   
178.                     .group(1));   
179.             if (matcherForAttrib.find()) {   
180.                 matcherForAttrib.appendReplacement(sbreplace, startTag   
181.                         + matcherForAttrib.group(1) + endTag);   
182.             }   
183.             matcherForTag.appendReplacement(sb, sbreplace.toString());   
184.             result = matcherForTag.find();   
185.         }   
186.         matcherForTag.appendTail(sb);   
187.         return sb.toString();   
188.     }   
189. }