JAVA 正则表达式（查找Java注释行数）

Question

我现在遇到一个正则表达式真不会写：
  我现在要扫描一个java文件，使用正则表达式分析这个文件里有多少行注释，但是我写的正则表达式有缺陷，
如果这个注释（//或者/*）包含在一个字符串里中（“xx//xx”）就会把一行代码也当成注释，
例如：
   代码1：System.out.println("gaga,nihao/*,haha");            我会把这行代码以下的代码也分析为注释，直到找到一个*/，   代码2：System.out.println("gaga,nihao,haha");//xxxx, /*   
         System.out.println("gaga,nihao,haha"); /×xxxx,//                          注释我会把这2行代码注释我也搞的很乱，怎么写一个正则式可以分析java注释行数，但是又可以排除掉种种问题，辛苦看这个帖的高手们，帮帮搞定它

Answer 1

原来做的把 Java 代码在字符串、注释、常量等处添加高亮的代码，对于注释的处理方式可以参考一下
（代码较多分多楼贴出），代码是将自身的 Java 文件输出：import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;import org.apache.commons.lang.StringUtils;import com.bao.util.io.FileUtil;public class Test {    public static void main(String[] args) throws IOException {
        String str = FileUtil.readFile2String("E:/myprog/eclipse33/csdn/src/net/csdn/java/regex/Test.java");
        JavaSyntaxHighlight java = new JavaSyntaxHighlight(str);
        System.out.println(java.process());
    }
}/**
 * Java 语法高亮
 */
class JavaSyntaxHighlight {    /**
     * 关键词
     */
    private static String keywords = "abstract assert boolean break byte case catch char class const " +
            "continue default do double else enum extends false final finally " +
            "float for if goto implements import instanceof int interface long " +
            "native new null package private protected public return short static " +
            "strictfp super switch synchronized this throw throws transient true try " +
            "void volatile while";
    
    /**
     * 多行注释
     */
    private final static String MULTI_COMMENT = "/\\*[^*]*\\*+(?:[^/*][^*]*\\*+)*/";
    
    /**
     * 单行注释
     */
    private final static String SINGLE_COMMENT = "//[^\\r\\n]*+";
    
    /**
     * 字符串
     */
    private final static String QUOTE_STRING = "\"[^\\\\\"]*(?:\\\\.[^\\\\\"]*)*\"";
    
    /**
     * 字符
     */
    private final static String QUOTE_CHAR = "'[^\\\\']*(?:\\\\.[^\\\\']*)*'";
    
    /**
     * 高亮标签 
     */
    private final static String HIGHLIGHT_HTML_TAG = "<span(?s:.+?)/span>";
    
    /**
     * 组合关键词表达式
     */
    private final static String KEYWORDS = "@interface|\\b(?:" + keywords.replace(' ', '|') + ")\\b";
    
    /**
     * 静态常量
     */
    private final static String STATIC_CONST = "(?<=\\b[A-Z_][A-Za-z0-9_]{0,50}\\.|[\\s({])[A-Z_][A-Z0-9_]*(?=\\s*[=+;,)}])";
    
    /**
     * Annotation
     */
    private final static String ANNOTATION = "@[A-Z_][A-Za-z0-9_]*\\b";
    
    private HighlightFormatter keywordFormatter         = HighlightFormatter.DEFAULT_KEYWORDS_CLASS;
    private HighlightFormatter multiCommentFormatter    = HighlightFormatter.DEFAULT_MULTICOMMENT_CLASS;
    private HighlightFormatter singleCommentFormatter   = HighlightFormatter.DEFAULT_SINGLECOMMENT_CLASS;
    private HighlightFormatter stringFormatter          = HighlightFormatter.DEFAULT_STRING_CLASS;
    private HighlightFormatter staticConstFormatter     = HighlightFormatter.DEFAULT_STATIC_CONST;
    private HighlightFormatter annotationFormatter      = HighlightFormatter.DEFAULT_ANNOTATION;
    
    private String text;
    
    /**
     * 匹配字符串的正则表达式
     */
    private final static Pattern REGEX_QUOTE_STRING = Pattern.compile(
            "(" + HIGHLIGHT_HTML_TAG + "|" + SINGLE_COMMENT + "|" + MULTI_COMMENT + ")|" +
            "(" + QUOTE_STRING + ")"    
        );
    
    /**
     * 匹配字符的正则表达式
     */    
    private final static Pattern REGEX_QUOTE_CHAR = Pattern.compile(
            "(" + HIGHLIGHT_HTML_TAG + "|" + SINGLE_COMMENT + "|" + MULTI_COMMENT + ")|" +
            "(" + QUOTE_CHAR + ")"    
        );
    
    /**
     * 匹配多行注释的正则表达式
     */
    private final static Pattern REGEX_MULTI_COMMENT = Pattern.compile(
            "(" + HIGHLIGHT_HTML_TAG + "|" + SINGLE_COMMENT + "|" + QUOTE_STRING + ")|" +
            "(" + MULTI_COMMENT + ")"    
        );
    
    /**
     * 匹配单行注释的正则表达式
     */
    private final static Pattern REGEX_SINGLE_COMMENT = Pattern.compile(
            "(" + HIGHLIGHT_HTML_TAG + "|" + MULTI_COMMENT + "|" + QUOTE_STRING + ")|" +
            "(" + SINGLE_COMMENT + ")"    
        );
    
    /**
     * 匹配 Java 关键词的正则表达式
     */
    private final static Pattern REGEX_KEYWORDS = Pattern.compile(
            "(" + HIGHLIGHT_HTML_TAG + "|" + MULTI_COMMENT + "|" + QUOTE_STRING + "|" + SINGLE_COMMENT + ")|" +
            "(" + KEYWORDS + ")"    
        );
    
    /**
     * 匹配静态常量的正则表达式
     */
    private final static Pattern REGEX_STATIC = Pattern.compile(
            "(" + HIGHLIGHT_HTML_TAG + "|" + MULTI_COMMENT + "|" + QUOTE_STRING + "|" + SINGLE_COMMENT + ")|" +
            "(" + STATIC_CONST + ")"
        );
    
    /**
     * 匹配 @ 注释的正则表达式
     */
    private final static Pattern REGEX_ANNOTATION = Pattern.compile(
            "(" + HIGHLIGHT_HTML_TAG + "|" + MULTI_COMMENT + "|" + QUOTE_STRING + "|" + SINGLE_COMMENT + ")|" +
            "(" + ANNOTATION + ")"
        );
    
    public JavaSyntaxHighlight(String text) {
        this.text = text;
    }
    
    public String process() {
        text = processHtmlEscape(text);        
        process(REGEX_QUOTE_STRING, stringFormatter);
        process(REGEX_KEYWORDS, keywordFormatter);
        process(REGEX_QUOTE_CHAR, stringFormatter);
        process(REGEX_MULTI_COMMENT, multiCommentFormatter);
        process(REGEX_SINGLE_COMMENT, singleCommentFormatter);
        process(REGEX_STATIC, staticConstFormatter);
        process(REGEX_ANNOTATION, annotationFormatter);
        return text;
    }    
    
    private void process(Pattern regex, HighlightFormatter formatter) {        
        Matcher matcher = regex.matcher(text);
        StringBuffer sb = new StringBuffer();
        while(matcher.find()) {
            if(matcher.start(1) > -1) {
                String str = matcher.group(1);
                str = processSpecialChar(str);
                matcher.appendReplacement(sb, str);
            } else if(matcher.start(2) > -1) {
                String str = matcher.group(2);
                str = processSpecialChar(str);
                matcher.appendReplacement(sb, formatter.getHtmlPrefix() + str + formatter.getHtmlSuffix());                
            }    
        }
        matcher.appendTail(sb);
        text = sb.toString();
    }
    
    private String processHtmlEscape(String str) {
        return str.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
    }
    
    /**
     * 处理替换后的特殊字符
     * @param str
     * @return
     */    
    private String processSpecialChar(String str) {
        if(str.indexOf('\\') > -1) {
            str = str.replace("\\", "\\\\");
        }
        if(str.indexOf('$') > -1) {
            str = str.replace("$", "\\$");
        }
        return str;
    }
}

Answer 2

class HighlightFormatter {
    private String color;
    private boolean isBold;
    private boolean isItalic;
    private String font;
    private String size;
    
    private String styleClass;
    
    public final static String COLOR_DEFAULT = "#000000";       // default font
    public final static String FONT_DEFAULT = "Courier New";    // default color
    public final static String SIZE_DEFAULT = "12pt";           // default font size
    
    // highlight format of keywords
    public final static HighlightFormatter DEFAULT_KEYWORDS_CLASS       = new HighlightFormatter("keywords");
    public final static HighlightFormatter DEFAULT_MULTICOMMENT_CLASS   = new HighlightFormatter("multiComments");
    public final static HighlightFormatter DEFAULT_SINGLECOMMENT_CLASS  = new HighlightFormatter("singleComments");
    public final static HighlightFormatter DEFAULT_STRING_CLASS         = new HighlightFormatter("string");
    public final static HighlightFormatter DEFAULT_STATIC_CONST         = new HighlightFormatter("static");
    public final static HighlightFormatter DEFAULT_ANNOTATION           = new HighlightFormatter("annotation");
    
    /**
     * Using HTML style attribute
     * @param color
     * @param isBold
     * @param isItalic
     * @param font
     * @param size
     */
    public HighlightFormatter(String color, boolean isBold, boolean isItalic,
            String font, String size) {
        setColor(color);
        setBold(isBold);
        setItalic(isItalic);
        setFont(font);
        setSize(size);
    }
    
    /**
     * Using CSS class selector
     * @param styleClass
     */
    public HighlightFormatter(String styleClass) {
        this.styleClass = styleClass;
    }
    
    public HighlightFormatter() {
        
    }
    
    public String getHtmlPrefix() {
        StringBuilder sb = new StringBuilder();
        sb.append("<").append("span");
        if(StringUtils.isNotEmpty(styleClass)) {
            sb.append(" class=\"").append(styleClass).append("\">");
            return sb.toString();
        }
        sb.append(" style=\"");
        if(StringUtils.isNotEmpty(font) || isBold || isItalic || StringUtils.isNotEmpty(size)) {
            sb.append("font:");
            if(isItalic) {
                sb.append(" italic");
            }
            if(isBold) {
                sb.append(" bold");                
            }
            if(StringUtils.isNotEmpty(size)) {
                sb.append(" ").append(size);
            }
            if(StringUtils.isNotEmpty(font)) {
                sb.append(" ").append(font);
            }
            sb.append("; ");
        }
        if(StringUtils.isNotEmpty(color)) {
            sb.append("color: ").append(color).append("; ");
        }
        sb.append("\">");
        return sb.toString();
    }
    
    public String getHtmlSuffix() {
        return "</span>"; 
    }
    
    private String processFont(String font) {
        String[] fonts = font.split(",\\s*");
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < fonts.length; i++) {
            if(i > 0) {
                sb.append(",");
            }
            if(fonts[i].indexOf(' ') > -1) {
                sb.append("\"").append(fonts[i]).append("\"");
            } else {
                sb.append(fonts[i]);
            }            
        }
        return sb.toString();
    }
    
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public boolean isBold() {
        return isBold;
    }
    public void setBold(boolean isBold) {
        this.isBold = isBold;
    }
    public boolean isItalic() {
        return isItalic;
    }
    public void setItalic(boolean isItalic) {
        this.isItalic = isItalic;
    }
    public String getFont() {
        return font;
    }
    public void setFont(String font) {
        this.font = processFont(font);
    }
    public String getSize() {
        return size;
    }
    public void setSize(String size) {
        this.size = size;
    }    public String getStyleClass() {
        return styleClass;
    }    public void setStyleClass(String styleClass) {
        this.styleClass = styleClass;
    }
}用于观察效果的 HTML：<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=gbk" />
  <title> new document </title>
</head><style type="text/css">
.syntax {
  font-family: "courier new";
  font-size: 10pt;
  border: 1px solid #c0c0c0;
  padding: 10px 15px;
}
.syntax .keywords {
  color: #004080;
  font-weight: bold;
}
.syntax .string {
  color: red;
}
.syntax .singleComments {
  color: limegreen;
}
.syntax .multiComments {
  color: gray;
}
.syntax .static {
  color: blue;
  font-style: italic;
}
</style><body>
<pre class="syntax"><!-- 代码 --></pre>
</body>
</html>

Answer 3

我ka果子你够狠的（@*&%￥@#%
其实用js就行了
b test（a）
a是regex
b是document
算了，那不比你这个简单
当我没说过吧，，，，

Answer 4

一、查找字符串，然后把字符串替换成空字符串
如：
"abc" => ""
"\"" => ""
"\\" => ""
"x//y" => ""
"/*/*" => ""
yourContent.replaceAll("\"([\\]["\\]|[^"])\"", "")
二、把含有//和/*..*/的内容中非'\n'替换成你的特殊标记，比如当前的时间new Date().getTime()，然后统计出含有多少这个标记，那就有多少行注释