Con respecto a la exclusión de líneas comentadas

I was trying to develop the application that count the line of code my source file is ..

package asd;
    public class abv {
        /**
         * @param args
         */
        public static void main(String[] args) {
    // comment
    /* comment*/
        }
    }

and below is the piece of code.....

 private static int totalLineCount = 0;
    private static int totalFileScannedCount = 0;

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

        JFileChooser chooser = new JFileChooser();
        chooser.setCurrentDirectory(new java.io.File("C:" + File.separator));
        chooser.setDialogTitle("FILES ALONG WITH LINE NUMBERS");
        chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
        chooser.setAcceptAllFileFilterUsed(false);
        if (chooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
            Map<File, Integer> result = new HashMap<File, Integer>();
            File directory = new File(chooser.getSelectedFile().getAbsolutePath());

            List<File> files = getFileListing(directory);

            // print out all file names, in the the order of File.compareTo()
            for (File file : files) {
               // System.out.println("Directory: " + file);
                getFileLineCount(result, file);
                //totalFileScannedCount += result.size(); //saral
            }

            System.out.println("*****************************************");
            System.out.println("FILE NAME FOLLOWED BY LOC");
            System.out.println("*****************************************");

            for (Map.Entry<File, Integer> entry : result.entrySet()) {
                System.out.println(entry.getKey().getAbsolutePath() + " ==> " + entry.getValue());
            }
            System.out.println("*****************************************");
            System.out.println("SUM OF FILES SCANNED ==>" + "\t" + totalFileScannedCount);
            System.out.println("SUM OF ALL THE LINES ==>" + "\t" + totalLineCount);
        }

    }


    public static void getFileLineCount(final Map<File, Integer> result, final File directory)
            throws FileNotFoundException {
        File[] files = directory.listFiles(new FilenameFilter() {

            public boolean accept(final File directory, final String name) {
                if (name.endsWith(".java")) {
                    return true;
                } else {
                    return false;
                }
            }
        });
        for (File file : files) {
            if (file.isFile()) {
                Scanner scanner = new Scanner(new FileReader(file));
                int lineCount = 0;
                totalFileScannedCount ++; //saral
                try {

                    /*for (lineCount = 0; scanner.nextLine() != null;lineCount++ ) { //saral
                        ;


                    }*/


                    while (scanner.hasNextLine()) {
                           String line = scanner.nextLine().trim();
                           if (!line.isEmpty()) {
                              System.out.println("debug-->"+line); // to debug cross checked that no whitespaces are there 
                             lineCount++;
                           }
                    }

                     result.put(file, lineCount);
                     totalLineCount += lineCount;                               
                } catch (NoSuchElementException e) {
                    // e.printStackTrace();
                }
            }
        }

    }

    /**
     * Recursively walk a directory tree and return a List of all Files found;
     * the List is sorted using File.compareTo().
     * 
     * @param aStartingDir
     *            is a valid directory, which can be read.
     */
    static public List<File> getFileListing(final File aStartingDir) throws FileNotFoundException {
        validateDirectory(aStartingDir);
        List<File> result = getFileListingNoSort(aStartingDir);
        Collections.sort(result);
        return result;
    }

    // PRIVATE //
    static private List<File> getFileListingNoSort(final File aStartingDir) throws FileNotFoundException {
        List<File> result = new ArrayList<File>();
        File[] filesAndDirs = aStartingDir.listFiles();
        List<File> filesDirs = Arrays.asList(filesAndDirs);
        for (File file : filesDirs) {
            if (file.isDirectory()) {
                result.add(file);
            }
            if (!file.isFile()) {
                // must be a directory
                // recursive call!
                List<File> deeperList = getFileListingNoSort(file);
                result.addAll(deeperList);
            }
        }
        return result;
    }

    /**
     * Directory is valid if it exists, does not represent a file, and can be
     * read.
     */
    static private void validateDirectory(final File aDirectory) throws FileNotFoundException {
        if (aDirectory == null) {
            throw new IllegalArgumentException("Directory should not be null.");
        }
        if (!aDirectory.exists()) {
            throw new FileNotFoundException("Directory does not exist: " + aDirectory);
        }
        if (!aDirectory.isDirectory()) {
            throw new IllegalArgumentException("Is not a directory: " + aDirectory);
        }
        if (!aDirectory.canRead()) {
            throw new IllegalArgumentException("Directory cannot be read: " + aDirectory);
        }
    }

Now the problem comes is that. when I select the project folder and see the results on the console it counts the line of code of my java file but it also count the comments too, I want not even comments to be get counted , means that commented lines not to be get counted as lines of code , Please advise what modifications need to be done in the piece of code...

below is the output I AM GETTING ON CONSOLE..

debug-->package asd;
debug-->public class abv {
debug-->/**
debug-->* @param args
debug-->*/
debug-->public static void main(String[] args) {
debug-->// comment
debug-->/* comment*/
debug-->}
debug-->}
*****************************************
FILE NAME FOLLOWED BY LOC
*****************************************
C:\Users\vaio\Desktop\Demo\fg\src\asd\abv.java ==> 10
*****************************************
SUM OF FILES SCANNED ==>    1
SUM OF ALL THE LINES ==>    10

Please advise what modifications need to be done in the piece of code...

preguntado el 01 de julio de 12 a las 07:07

2 Respuestas

My first stab at this would be to use regular expressions. Given that a source file isn't going to be that large, you could read the entire set of lines into a string, run a regex that replaces all comments with nothing, and then count the lines in the new string.

My Java is a bit rusty but I believe this will work (don't have an environment to test right now):

int count = 0;
Scanner scanner = new Scanner(new File(file));
scanner.useDelimiter("\\Z");
String data = scanner.next();
String cleaned = data.replaceAll("/\\*(?:.|[\\n\\r])*?\\*/",""));
LineNumberReader lnr = new LineNumberReader(new StringReader(cleaned));
String line;
while ((line = lnr.readLine()) != null)
{
    String sline = line.trim();
    if(sline.isEmpty() == false)
        if(!(sline.length() > 2 && sline.charAt(0) == '/' && sline.charAt(1) == '/'))
            count += 1;
            //separated for clarity
}

This should give you the number of lines that are not all comment // and also handle multiline comments.

Source on regex for comments: Regex source

Respondido 01 Jul 12, 08:07

My former answer was not correct. Because you ticked it as correct so I used the code of @Trickfire to edit my answer.

while (scanner.hasNextLine()) {

                   scanner.useDelimiter("\\Z");
                   String data = scanner.next();
                   String cleaned = data.replaceAll("/\\*(?:.|[\\n\\r])*?\\*/",""));
                   LineNumberReader lnr = new LineNumberReader(new StringReader(cleaned));
                   String line;
                   while ((line = lnr.readLine()) != null)
                    {
                      String sline = line.trim();
                      if(sline.isEmpty() == false)
                      if(!(sline.length() > 2 && sline.charAt(0) == '/' && sline.charAt(1) == '/'))
                          lineCount += 1;
                           //separated for clarity
                   }


                }

Respondido 01 Jul 12, 08:07

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.