Removing all types of comments in java file

问题:

I have a java project and i have used comments in many location in various java files in the project. Now i need to remove all type of comments : single line , multiple line comments . Please provide automation for removing comments. using tools or in eclipse etc.

Currently i am manually trying to remove all commetns

回答1:

I had to write somehting to do this a few weeks ago. This should handle all comments, nested or otherwise. It is long, but I haven't seen a regex version that handled nested comments properly. I didn't have to preserve javadoc, but I presume you do, so I added some code that I belive should handle that. I also added code to support the \r\n and \r line separators. The new code is marked as such.

public static String removeComments(String code) {
    StringBuilder newCode = new StringBuilder();
    try (StringReader sr = new StringReader(code)) {
        boolean inBlockComment = false;
        boolean inLineComment = false;
        boolean out = true;

        int prev = sr.read();
        int cur;
        for(cur = sr.read(); cur != -1; cur = sr.read()) {
            if(inBlockComment) {
                if (prev == '*' && cur == '/') {
                    inBlockComment = false;
                    out = false;
                }
            } else if (inLineComment) {
                if (cur == '\r') { // start untested block
                    sr.mark(1);
                    int next = sr.read();
                    if (next != '\n') {
                        sr.reset();
                    }
                    inLineComment = false;
                    out = false; // end untested block
                } else if (cur == '\n') {
                    inLineComment = false;
                    out = false;
                }
            } else {
                if (prev == '/' && cur == '*') {
                    sr.mark(1); // start untested block
                    int next = sr.read();
                    if (next != '*') {
                        inBlockComment = true; // tested line (without rest of block)
                    }
                    sr.reset(); // end untested block
                } else if (prev == '/' && cur == '/') {
                    inLineComment = true;
                } else if (out){
                    newCode.append((char)prev);
                } else {
                    out = true;
                }
            }
            prev = cur;
        }
        if (prev != -1 && out && !inLineComment) {
            newCode.append((char)prev);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    return newCode.toString();
}

回答2:

You can remove all single- or multi-line block comments (but not line comments with //) by searching for the following regular expression in your project(s)/file(s) and replacing by $1:

^([^"\r\n]*?(?:(?<=')"[^"\r\n]*?|(?<!')"[^"\r\n]*?"[^"\r\n]*?)*?)(?<!/)/\*[^\*]*(?:\*+[^/][^\*]*)*?\*+/

It's possible that you have to execute it more than once.

This regular expression avoids the following pitfalls:

1. Code between two comments /* Comment 1 */ foo(); /* Comment 2 */

2. Line comments starting with an asterisk: //***NOTE***

3. Comment delimiters inside string literals: stringbuilder.append("/*");; also if there is a double quote inside single quotes before the comment

To remove all single-line comments, search for the following regular expression in your project(s)/file(s) and replacing by $1:

^([^"\r\n]*?(?:(?<=')"[^"\r\n]*?|(?<!')"[^"\r\n]*?"[^"\r\n]*?)*?)\s*//[^\r\n]*

This regular expression also avoids comment delimiters inside double quotes, but does NOT check for multi-line comments, so /* // */ will be incorrectly removed.

回答3:

you can try it with the java-comment-preprocessor:

java -jar ./jcp-6.0.0.jar --i:/sourceFolder --o:/resultFolder -ef:none --r

source

回答4:

Dealing with source code is hard unless you know more on the writing of comment. In the more general case, you could have // or /* in text constants. So your really need to parse the file at a syntaxic level, not only lexical. IMHO the only bulletproof solution would be to start for example with the java parser from openjdk.

If you know that your comments are never deeply mixed with the code (in my exemple comments MUST be full lines), a python script could help

multiple = False
for line in text:
    stripped = line.strip()
    if multiple:
        if stripped.endswith('*/'):
            multiple = False
            continue
    elif stripped.startswith('/*'):
        multiple = True
    elif stripped.startswith('//'):
        pass
    else:
        print(line)

回答5:

If you are using Eclipse IDE, you could make regex do the work for you.

Open the search window (Ctrl+F), and check 'Regular Expression'.

Provide the expression as /\*\*(?s:(?!\*/).)*\*/

Prasanth Bhate has explained it in Tool to remove JavaDoc comments?

回答6:

This is an old post but this may help someone who enjoys working on command line like myself:

The perl one-liner below will remove all comments:

perl -0pe 's|//.*?\n|\n|g; s#/\*(.|\n)*?\*/##g;' test.java

Example:

cat test.java
this is a test

/**
*This should be removed
*This should be removed
*/

this should not be removed

//this should be removed

this should not be removed

this should not be removed //this should be removed

Output:

perl -0pe 's#/\*\*(.|\n)*?\*/##g; s|//.*?\n|\n|g' test.java
this is a test



this should not be removed



this should not be removed

this should not be removed 

If you want get rid of multiple blank lines as well:

perl -0pe 's|//.*?\n|\n|g; s#/\*(.|\n)*?\*/##g; s/\n\n+/\n\n/g' test.java
this is a test

this should not be removed

this should not be removed

this should not be removed 

EDIT: Corrected regex

回答7:

I made a open source library and uploaded to github, its called CommentRemover you can remove single line and multiple line Java Comments.

It supports remove or NOT remove TODO's.
Also it supports JavaScript , HTML , CSS , Properties , JSP and XML Comments too.

There is a little code snippet how to use it (There is 2 type usage):

First way InternalPath

 public static void main(String[] args) throws CommentRemoverException {

 // root dir is: /Users/user/Projects/MyProject
 // example for startInternalPath

 CommentRemover commentRemover = new CommentRemover.CommentRemoverBuilder()
        .removeJava(true) // Remove Java file Comments....
        .removeJavaScript(true) // Remove JavaScript file Comments....
        .removeJSP(true) // etc.. goes like that
        .removeTodos(false) //  Do Not Touch Todos (leave them alone)
        .removeSingleLines(true) // Remove single line type comments
        .removeMultiLines(true) // Remove multiple type comments
        .startInternalPath("src.main.app") // Starts from {rootDir}/src/main/app , leave it empty string when you want to start from root dir
        .setExcludePackages(new String[]{"src.main.java.app.pattern"}) // Refers to {rootDir}/src/main/java/app/pattern and skips this directory
        .build();

 CommentProcessor commentProcessor = new CommentProcessor(commentRemover);
                  commentProcessor.start();        
  }

Second way ExternalPath

 public static void main(String[] args) throws CommentRemoverException {

 // example for externalInternalPath

 CommentRemover commentRemover = new CommentRemover.CommentRemoverBuilder()
        .removeJava(true) // Remove Java file Comments....
        .removeJavaScript(true) // Remove JavaScript file Comments....
        .removeJSP(true) // etc..
        .removeTodos(true) // Remove todos
        .removeSingleLines(false) // Do not remove single line type comments
        .removeMultiLines(true) // Remove multiple type comments
        .startExternalPath("/Users/user/Projects/MyOtherProject")// Give it full path for external directories
        .setExcludePackages(new String[]{"src.main.java.model"}) // Refers to /Users/user/Projects/MyOtherProject/src/main/java/model and skips this directory.
        .build();

 CommentProcessor commentProcessor = new CommentProcessor(commentRemover);
                  commentProcessor.start();        
  }

回答8:

This is what I came up with yesterday. This is actually homework I got from school so if anybody reads this and finds a bug before I turn it in, please leave a comment =)

ps. 'FilterState' is a enum class

public static String deleteComments(String javaCode) {
    FilterState state = FilterState.IN_CODE;

    StringBuilder strB = new StringBuilder();

    char prevC=' ';
    for(int i = 0; i<javaCode.length(); i++){
        char c = javaCode.charAt(i);
        switch(state){
            case IN_CODE:
                if(c=='/')
                    state = FilterState.CAN_BE_COMMENT_START;
                else {
                    if (c == '"')
                        state = FilterState.INSIDE_STRING;
                    strB.append(c);
                }
                break;
            case CAN_BE_COMMENT_START:
                if(c=='*'){
                    state = FilterState.IN_COMMENT_BLOCK;
                }
                else if(c=='/'){
                    state = FilterState.ON_COMMENT_LINE;
                }
                else {
                    state = FilterState.IN_CODE;
                    strB.append(prevC+c);
                }
                break;
            case ON_COMMENT_LINE:
                if(c=='\n' || c=='\r') {
                    state = FilterState.IN_CODE;
                    strB.append(c);
                }
                break;
            case IN_COMMENT_BLOCK:
                if(c=='*')
                    state=FilterState.CAN_BE_COMMENT_END;
                break;
            case CAN_BE_COMMENT_END:
                if(c=='/')
                    state = FilterState.IN_CODE;
                else if(c!='*')
                    state = FilterState.IN_COMMENT_BLOCK;
                break;
            case INSIDE_STRING:
                if(c == '"' && prevC!='\\')
                    state = FilterState.IN_CODE;
                strB.append(c);
                break;
            default:
                System.out.println("unknown case");
                return null;
        }
        prevC = c;
    }
    return strB.toString();
}

回答9:

public class TestForStrings {

/**
 * The main method.
 *
 * @param args
 *            the arguments
 * @throws Exception
 *             the exception
 */
public static void main(String args[]) throws Exception {

    String[] imports = new String[100];
    String fileName = "Menu.java";
    // This will reference one API at a time
    String line = null;
    try {
        FileReader fileReader = new FileReader(fileName);
        // Always wrap FileReader in BufferedReader.
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        int startingOffset = 0;

        // This will reference one API at a time

        List<String> lines = Files.readAllLines(Paths.get(fileName),
                Charset.forName("ISO-8859-1"));

        // remove single line comments
        for (int count = 0; count < lines.size(); count++) {
            String tempString = lines.get(count);

            lines.set(count, removeSingleLineComment(tempString));

        }
        // remove multiple lines comment
        for (int count = 0; count < lines.size(); count++) {
            String tempString = lines.get(count);

            removeMultipleLineComment(tempString, count, lines);
        }

        for (int count = 0; count < lines.size(); count++) {
            System.out.println(lines.get(count));
        }
    } catch (FileNotFoundException ex) {
        System.out.println("Unable to open file '" + fileName + "'");
    } catch (IOException ex) {
        System.out.println("Error reading file '" + fileName + "'");
    } catch (Exception e) {

    }

}

/**
 * Removes the multiple line comment.
 *
 * @param tempString
 *            the temp string
 * @param count
 *            the count
 * @param lines
 *            the lines
 * @return the string
 */
private static List<String> removeMultipleLineComment(String tempString,
        int count, List<String> lines) {
    try {
        if (tempString.contains("/**") || (tempString.contains("/*"))) {
            int StartIndex = count;
            while (!(lines.get(count).contains("*/") || lines.get(count)
                    .contains("**/"))) {
                count++;
            }
            int endIndex = ++count;
            if (StartIndex != endIndex) {
                while (StartIndex != endIndex) {
                    lines.set(StartIndex, "");
                    StartIndex++;
                }
            }
        }

    } catch (Exception e) {
        // Do Nothing
    }
    return lines;
}

/**
 * Remove single line comments .
 *
 * @param line
 *            the line
 * @return the string
 * @throws Exception
 *             the exception
 */

private static String removeSingleLineComment(String line) throws Exception {
    try {
        if (line.contains(("//"))) {
            int startIndex = line.indexOf("//");
            int endIndex = line.length();
            String tempoString = line.substring(startIndex, endIndex);
            line = line.replace(tempoString, "");
        }
        if ((line.contains("/*") || line.contains("/**"))
                && (line.contains("**/") || line.contains("*/"))) {
            int startIndex = line.indexOf("/**");
            int endIndex = line.length();
            String tempoString = line.substring(startIndex, endIndex);

            line = line.replace(tempoString, "");

        }

    } catch (Exception e) {
        // Do Nothing
    }
    return line;
}

}