Introduction
A comprehensive Code Metrics Calculator that analyzes Java source code to provide various software metrics including complexity, maintainability, and quality indicators.
Features
- Line Metrics: Count lines of code, comments, blanks
- Complexity Metrics: Cyclomatic complexity, method count
- Object-Oriented Metrics: Inheritance depth, coupling, cohesion
- Maintainability Index: Calculate code maintainability
- Halstead Metrics: Program volume, difficulty, effort
- Code Smell Detection: Identify potential issues
Core Implementation
Main Metrics Calculator Class
package com.codemetrics;
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.regex.*;
import java.util.stream.*;
public class CodeMetricsCalculator {
private final List<File> javaFiles;
private final MetricsResult totalMetrics;
private final List<FileMetrics> fileMetrics;
public CodeMetricsCalculator(String directoryPath) throws IOException {
this.javaFiles = findJavaFiles(directoryPath);
this.totalMetrics = new MetricsResult();
this.fileMetrics = new ArrayList<>();
}
public CodeMetricsCalculator(List<File> javaFiles) {
this.javaFiles = javaFiles;
this.totalMetrics = new MetricsResult();
this.fileMetrics = new ArrayList<>();
}
private List<File> findJavaFiles(String directoryPath) throws IOException {
Path startDir = Paths.get(directoryPath);
if (!Files.exists(startDir) || !Files.isDirectory(startDir)) {
throw new IllegalArgumentException("Directory does not exist: " + directoryPath);
}
try (Stream<Path> paths = Files.walk(startDir)) {
return paths
.filter(Files::isRegularFile)
.filter(path -> path.toString().endsWith(".java"))
.map(Path::toFile)
.collect(Collectors.toList());
}
}
public AnalysisResult analyze() {
System.out.println("Analyzing " + javaFiles.size() + " Java files...");
for (File javaFile : javaFiles) {
try {
FileMetrics metrics = analyzeFile(javaFile);
fileMetrics.add(metrics);
totalMetrics.aggregate(metrics.getMetrics());
} catch (IOException e) {
System.err.println("Error analyzing file: " + javaFile.getPath() + " - " + e.getMessage());
}
}
return new AnalysisResult(fileMetrics, totalMetrics);
}
private FileMetrics analyzeFile(File javaFile) throws IOException {
String content = new String(Files.readAllBytes(javaFile.toPath()));
FileMetrics metrics = new FileMetrics(javaFile.getName(), javaFile.getPath());
// Basic line metrics
calculateLineMetrics(content, metrics);
// Complexity metrics
calculateComplexityMetrics(content, metrics);
// OO metrics
calculateOOMetrics(content, metrics);
// Halstead metrics
calculateHalsteadMetrics(content, metrics);
// Maintainability index
calculateMaintainabilityIndex(metrics);
// Code smells
detectCodeSmells(content, metrics);
return metrics;
}
private void calculateLineMetrics(String content, FileMetrics metrics) {
String[] lines = content.split("\r\n|\r|\n");
int totalLines = lines.length;
int blankLines = 0;
int commentLines = 0;
int codeLines = 0;
boolean inBlockComment = false;
for (String line : lines) {
String trimmedLine = line.trim();
if (trimmedLine.isEmpty()) {
blankLines++;
continue;
}
if (inBlockComment) {
commentLines++;
if (trimmedLine.contains("*/")) {
inBlockComment = false;
}
continue;
}
if (trimmedLine.startsWith("/*")) {
commentLines++;
inBlockComment = !trimmedLine.contains("*/");
continue;
}
if (trimmedLine.startsWith("//")) {
commentLines++;
continue;
}
// Check for lines with code and comments
if (trimmedLine.contains("//")) {
commentLines++;
codeLines++; // Also counts as code line
continue;
}
codeLines++;
}
metrics.setLineMetrics(totalLines, blankLines, commentLines, codeLines);
}
private void calculateComplexityMetrics(String content, FileMetrics metrics) {
// Count methods
int methodCount = countMethods(content);
metrics.setMethodCount(methodCount);
// Calculate cyclomatic complexity
int complexity = calculateCyclomaticComplexity(content);
metrics.setCyclomaticComplexity(complexity);
// Average complexity per method
double avgComplexity = methodCount > 0 ? (double) complexity / methodCount : 0;
metrics.setAverageComplexity(avgComplexity);
}
private int countMethods(String content) {
// Pattern to match method declarations
Pattern methodPattern = Pattern.compile(
"(public|protected|private|static|\\s) +[\\w\\<\\>\\[\\]]+\\s+(\\w+) *\\([^)]*\\) *\\{? *\\n?",
Pattern.MULTILINE
);
Matcher matcher = methodPattern.matcher(content);
int count = 0;
while (matcher.find()) {
// Exclude constructors and simple getters/setters for more accurate count
String methodName = matcher.group(2);
if (!methodName.matches("^[A-Z].*") && // Not constructor
!methodName.matches("^(get|set|is).*")) { // Not simple accessor
count++;
}
}
return Math.max(count, 1); // At least 1 for the class itself
}
private int calculateCyclomaticComplexity(String content) {
int complexity = 1; // Base complexity
// Patterns for decision points
String[] decisionPatterns = {
"\\bif\\s*\\(", "\\belse\\s*\\{", "\\bfor\\s*\\(", "\\bwhile\\s*\\(",
"\\bcase\\b", "\\bdefault\\b", "\\bcatch\\s*\\(", "\\b&&\\b", "\\b\\|\\|\\b",
"\\?\\s*[^:]*\\s*:"
};
for (String pattern : decisionPatterns) {
Pattern p = Pattern.compile(pattern);
Matcher matcher = p.matcher(content);
while (matcher.find()) {
complexity++;
}
}
return complexity;
}
private void calculateOOMetrics(String content, FileMetrics metrics) {
// Count classes
int classCount = countPattern(content, "\\bclass\\s+\\w+");
metrics.setClassCount(classCount);
// Count interfaces
int interfaceCount = countPattern(content, "\\binterface\\s+\\w+");
metrics.setInterfaceCount(interfaceCount);
// Estimate inheritance depth (simplified)
int inheritanceDepth = estimateInheritanceDepth(content);
metrics.setInheritanceDepth(inheritanceDepth);
// Count dependencies (import statements)
int dependencyCount = countPattern(content, "^import\\s+.*", Pattern.MULTILINE);
metrics.setDependencyCount(dependencyCount);
}
private int countPattern(String content, String pattern) {
return countPattern(content, pattern, 0);
}
private int countPattern(String content, String pattern, int flags) {
Pattern p = Pattern.compile(pattern, flags);
Matcher matcher = p.matcher(content);
int count = 0;
while (matcher.find()) {
count++;
}
return count;
}
private int estimateInheritanceDepth(String content) {
// Simplified estimation - count "extends" and "implements"
int extendsCount = countPattern(content, "\\bextends\\b");
int implementsCount = countPattern(content, "\\bimplements\\b");
return extendsCount + implementsCount;
}
private void calculateHalsteadMetrics(String content, FileMetrics metrics) {
HalsteadMetrics halstead = new HalsteadMetrics();
// Extract operators and operands (simplified)
Set<String> operators = extractOperators(content);
Set<String> operands = extractOperands(content);
halstead.setUniqueOperators(operators.size());
halstead.setUniqueOperands(operands.size());
// Count total occurrences (simplified)
int totalOperators = countTotalOccurrences(content, operators);
int totalOperands = countTotalOccurrences(content, operands);
halstead.setTotalOperators(totalOperators);
halstead.setTotalOperands(totalOperands);
// Calculate derived metrics
halstead.calculateDerivedMetrics();
metrics.setHalsteadMetrics(halstead);
}
private Set<String> extractOperators(String content) {
Set<String> operators = new HashSet<>();
// Common Java operators
String[] javaOperators = {
"=", "+", "-", "*", "/", "%", "++", "--", "==", "!=", ">", "<", ">=", "<=",
"&&", "||", "!", "&", "|", "^", "~", "<<", ">>", ">>>", "+=", "-=", "*=",
"/=", "%=", "&=", "|=", "^=", "<<=", ">>=", ">>>=", "instanceof"
};
for (String op : javaOperators) {
if (content.contains(op)) {
operators.add(op);
}
}
// Add control flow keywords as operators
String[] controlFlow = {"if", "else", "for", "while", "do", "switch", "case", "break", "continue", "return"};
for (String cf : controlFlow) {
if (content.contains(cf)) {
operators.add(cf);
}
}
return operators;
}
private Set<String> extractOperands(String content) {
Set<String> operands = new HashSet<>();
// Extract identifiers (variable names, method names, etc.)
Pattern identifierPattern = Pattern.compile("\\b[a-zA-Z_$][a-zA-Z0-9_$]*\\b");
Matcher matcher = identifierPattern.matcher(content);
while (matcher.find()) {
String identifier = matcher.group();
// Exclude keywords
if (!isJavaKeyword(identifier)) {
operands.add(identifier);
}
}
return operands;
}
private boolean isJavaKeyword(String word) {
String[] keywords = {
"abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class",
"const", "continue", "default", "do", "double", "else", "enum", "extends", "final",
"finally", "float", "for", "goto", "if", "implements", "import", "instanceof", "int",
"interface", "long", "native", "new", "package", "private", "protected", "public",
"return", "short", "static", "strictfp", "super", "switch", "synchronized", "this",
"throw", "throws", "transient", "try", "void", "volatile", "while", "true", "false", "null"
};
return Arrays.asList(keywords).contains(word);
}
private int countTotalOccurrences(String content, Set<String> items) {
int count = 0;
for (String item : items) {
Pattern pattern = Pattern.compile("\\b" + Pattern.quote(item) + "\\b");
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
count++;
}
}
return count;
}
private void calculateMaintainabilityIndex(FileMetrics metrics) {
MetricsResult m = metrics.getMetrics();
HalsteadMetrics h = metrics.getHalsteadMetrics();
// Simplified Maintainability Index calculation
double halsteadVolume = h.getVolume();
double cyclomaticComplexity = m.getCyclomaticComplexity();
double linesOfCode = m.getLinesOfCode();
// Avoid division by zero
if (halsteadVolume == 0) halsteadVolume = 1;
if (linesOfCode == 0) linesOfCode = 1;
// MI = 171 - 5.2 * ln(Halstead Volume) - 0.23 * (Cyclomatic Complexity) - 16.2 * ln(LOC)
double maintainabilityIndex = 171 - 5.2 * Math.log(halsteadVolume)
- 0.23 * cyclomaticComplexity
- 16.2 * Math.log(linesOfCode);
// Clamp between 0 and 100
maintainabilityIndex = Math.max(0, Math.min(100, maintainabilityIndex));
metrics.setMaintainabilityIndex(maintainabilityIndex);
}
private void detectCodeSmells(String content, FileMetrics metrics) {
List<CodeSmell> smells = new ArrayList<>();
// Detect long method
if (metrics.getMetrics().getLinesOfCode() > 50) {
smells.add(new CodeSmell("LONG_METHOD",
"Method might be too long (" + metrics.getMetrics().getLinesOfCode() + " lines)"));
}
// Detect high complexity
if (metrics.getMetrics().getCyclomaticComplexity() > 10) {
smells.add(new CodeSmell("HIGH_COMPLEXITY",
"High cyclomatic complexity (" + metrics.getMetrics().getCyclomaticComplexity() + ")"));
}
// Detect many parameters
detectManyParameters(content, smells);
// Detect duplicated code (simplified)
detectDuplicatedCode(content, smells);
metrics.setCodeSmells(smells);
}
private void detectManyParameters(String content, List<CodeSmell> smells) {
Pattern methodPattern = Pattern.compile("\\w+\\s+\\w+\\s*\\(([^)]*)\\)");
Matcher matcher = methodPattern.matcher(content);
while (matcher.find()) {
String params = matcher.group(1);
if (!params.trim().isEmpty()) {
int paramCount = params.split(",").length;
if (paramCount > 5) {
smells.add(new CodeSmell("MANY_PARAMETERS",
"Method has too many parameters (" + paramCount + ")"));
}
}
}
}
private void detectDuplicatedCode(String content, List<CodeSmell> smells) {
// Simplified duplication detection - look for repeated code blocks
String[] lines = content.split("\n");
Map<String, Integer> lineCounts = new HashMap<>();
for (String line : lines) {
String trimmed = line.trim();
if (trimmed.length() > 20 && !trimmed.startsWith("//")) {
lineCounts.put(trimmed, lineCounts.getOrDefault(trimmed, 0) + 1);
}
}
for (Map.Entry<String, Integer> entry : lineCounts.entrySet()) {
if (entry.getValue() > 3) {
smells.add(new CodeSmell("DUPLICATED_CODE",
"Possible code duplication (line repeated " + entry.getValue() + " times)"));
break; // Report only one instance to avoid spam
}
}
}
// Getters
public List<File> getJavaFiles() { return javaFiles; }
public List<FileMetrics> getFileMetrics() { return fileMetrics; }
}
Data Model Classes
package com.codemetrics;
import java.util.*;
public class MetricsResult {
private int linesOfCode;
private int blankLines;
private int commentLines;
private int codeLines;
private int methodCount;
private int classCount;
private int interfaceCount;
private int cyclomaticComplexity;
private double averageComplexity;
private int inheritanceDepth;
private int dependencyCount;
public MetricsResult() {}
public void aggregate(MetricsResult other) {
this.linesOfCode += other.linesOfCode;
this.blankLines += other.blankLines;
this.commentLines += other.commentLines;
this.codeLines += other.codeLines;
this.methodCount += other.methodCount;
this.classCount += other.classCount;
this.interfaceCount += other.interfaceCount;
this.cyclomaticComplexity += other.cyclomaticComplexity;
this.inheritanceDepth += other.inheritanceDepth;
this.dependencyCount += other.dependencyCount;
// Recalculate average
if (this.methodCount > 0) {
this.averageComplexity = (double) this.cyclomaticComplexity / this.methodCount;
}
}
// Getters and Setters
public int getLinesOfCode() { return linesOfCode; }
public void setLinesOfCode(int linesOfCode) { this.linesOfCode = linesOfCode; }
public int getBlankLines() { return blankLines; }
public void setBlankLines(int blankLines) { this.blankLines = blankLines; }
public int getCommentLines() { return commentLines; }
public void setCommentLines(int commentLines) { this.commentLines = commentLines; }
public int getCodeLines() { return codeLines; }
public void setCodeLines(int codeLines) { this.codeLines = codeLines; }
public int getMethodCount() { return methodCount; }
public void setMethodCount(int methodCount) { this.methodCount = methodCount; }
public int getClassCount() { return classCount; }
public void setClassCount(int classCount) { this.classCount = classCount; }
public int getInterfaceCount() { return interfaceCount; }
public void setInterfaceCount(int interfaceCount) { this.interfaceCount = interfaceCount; }
public int getCyclomaticComplexity() { return cyclomaticComplexity; }
public void setCyclomaticComplexity(int cyclomaticComplexity) {
this.cyclomaticComplexity = cyclomaticComplexity;
}
public double getAverageComplexity() { return averageComplexity; }
public void setAverageComplexity(double averageComplexity) {
this.averageComplexity = averageComplexity;
}
public int getInheritanceDepth() { return inheritanceDepth; }
public void setInheritanceDepth(int inheritanceDepth) { this.inheritanceDepth = inheritanceDepth; }
public int getDependencyCount() { return dependencyCount; }
public void setDependencyCount(int dependencyCount) { this.dependencyCount = dependencyCount; }
}
class FileMetrics {
private final String fileName;
private final String filePath;
private final MetricsResult metrics;
private HalsteadMetrics halsteadMetrics;
private double maintainabilityIndex;
private List<CodeSmell> codeSmells;
public FileMetrics(String fileName, String filePath) {
this.fileName = fileName;
this.filePath = filePath;
this.metrics = new MetricsResult();
this.halsteadMetrics = new HalsteadMetrics();
this.codeSmells = new ArrayList<>();
}
public void setLineMetrics(int totalLines, int blankLines, int commentLines, int codeLines) {
metrics.setLinesOfCode(totalLines);
metrics.setBlankLines(blankLines);
metrics.setCommentLines(commentLines);
metrics.setCodeLines(codeLines);
}
// Delegated methods for MetricsResult
public void setMethodCount(int count) { metrics.setMethodCount(count); }
public void setCyclomaticComplexity(int complexity) { metrics.setCyclomaticComplexity(complexity); }
public void setAverageComplexity(double avg) { metrics.setAverageComplexity(avg); }
public void setClassCount(int count) { metrics.setClassCount(count); }
public void setInterfaceCount(int count) { metrics.setInterfaceCount(count); }
public void setInheritanceDepth(int depth) { metrics.setInheritanceDepth(depth); }
public void setDependencyCount(int count) { metrics.setDependencyCount(count); }
// Getters
public String getFileName() { return fileName; }
public String getFilePath() { return filePath; }
public MetricsResult getMetrics() { return metrics; }
public HalsteadMetrics getHalsteadMetrics() { return halsteadMetrics; }
public void setHalsteadMetrics(HalsteadMetrics halsteadMetrics) { this.halsteadMetrics = halsteadMetrics; }
public double getMaintainabilityIndex() { return maintainabilityIndex; }
public void setMaintainabilityIndex(double maintainabilityIndex) { this.maintainabilityIndex = maintainabilityIndex; }
public List<CodeSmell> getCodeSmells() { return codeSmells; }
public void setCodeSmells(List<CodeSmell> codeSmells) { this.codeSmells = codeSmells; }
}
class HalsteadMetrics {
private int uniqueOperators;
private int uniqueOperands;
private int totalOperators;
private int totalOperands;
private double vocabulary;
private double length;
private double volume;
private double difficulty;
private double effort;
public void calculateDerivedMetrics() {
this.vocabulary = uniqueOperators + uniqueOperands;
this.length = totalOperators + totalOperands;
if (vocabulary > 0) {
this.volume = length * (Math.log(vocabulary) / Math.log(2));
}
if (uniqueOperators > 0 && uniqueOperands > 0) {
this.difficulty = ((double) uniqueOperators / 2) * ((double) totalOperands / uniqueOperands);
this.effort = difficulty * volume;
}
}
// Getters and Setters
public int getUniqueOperators() { return uniqueOperators; }
public void setUniqueOperators(int uniqueOperators) { this.uniqueOperators = uniqueOperators; }
public int getUniqueOperands() { return uniqueOperands; }
public void setUniqueOperands(int uniqueOperands) { this.uniqueOperands = uniqueOperands; }
public int getTotalOperators() { return totalOperators; }
public void setTotalOperators(int totalOperators) { this.totalOperators = totalOperators; }
public int getTotalOperands() { return totalOperands; }
public void setTotalOperands(int totalOperands) { this.totalOperands = totalOperands; }
public double getVocabulary() { return vocabulary; }
public double getLength() { return length; }
public double getVolume() { return volume; }
public double getDifficulty() { return difficulty; }
public double getEffort() { return effort; }
}
class CodeSmell {
private final String type;
private final String description;
private final Date detectedAt;
public CodeSmell(String type, String description) {
this.type = type;
this.description = description;
this.detectedAt = new Date();
}
// Getters
public String getType() { return type; }
public String getDescription() { return description; }
public Date getDetectedAt() { return detectedAt; }
@Override
public String toString() {
return type + ": " + description;
}
}
class AnalysisResult {
private final List<FileMetrics> fileMetrics;
private final MetricsResult totalMetrics;
public AnalysisResult(List<FileMetrics> fileMetrics, MetricsResult totalMetrics) {
this.fileMetrics = fileMetrics;
this.totalMetrics = totalMetrics;
}
// Getters
public List<FileMetrics> getFileMetrics() { return fileMetrics; }
public MetricsResult getTotalMetrics() { return totalMetrics; }
}
Report Generators
package com.codemetrics;
import java.util.*;
import java.util.stream.Collectors;
public class MetricsReporter {
public static void generateConsoleReport(AnalysisResult result) {
System.out.println("=== CODE METRICS ANALYSIS REPORT ===");
System.out.println();
generateSummaryReport(result);
System.out.println();
generateDetailedReport(result);
System.out.println();
generateCodeSmellsReport(result);
System.out.println();
generateRecommendations(result);
}
private static void generateSummaryReport(AnalysisResult result) {
MetricsResult total = result.getTotalMetrics();
System.out.println("SUMMARY METRICS");
System.out.println("===============");
System.out.printf("Files Analyzed: %d%n", result.getFileMetrics().size());
System.out.printf("Total Lines: %d%n", total.getLinesOfCode());
System.out.printf("Code Lines: %d (%.1f%%)%n",
total.getCodeLines(), percentage(total.getCodeLines(), total.getLinesOfCode()));
System.out.printf("Comment Lines: %d (%.1f%%)%n",
total.getCommentLines(), percentage(total.getCommentLines(), total.getLinesOfCode()));
System.out.printf("Blank Lines: %d (%.1f%%)%n",
total.getBlankLines(), percentage(total.getBlankLines(), total.getLinesOfCode()));
System.out.printf("Comment Density: %.1f%%%n",
percentage(total.getCommentLines(), total.getCommentLines() + total.getCodeLines()));
System.out.println();
System.out.printf("Classes: %d%n", total.getClassCount());
System.out.printf("Interfaces: %d%n", total.getInterfaceCount());
System.out.printf("Methods: %d%n", total.getMethodCount());
System.out.printf("Total Cyclomatic Complexity: %d%n", total.getCyclomaticComplexity());
System.out.printf("Average Complexity/Method: %.2f%n", total.getAverageComplexity());
System.out.printf("Average Inheritance Depth: %.2f%n",
(double) total.getInheritanceDepth() / Math.max(total.getClassCount(), 1));
}
private static void generateDetailedReport(AnalysisResult result) {
System.out.println("DETAILED FILE METRICS");
System.out.println("=====================");
System.out.printf("%-30s %6s %6s %6s %6s %6s %6s %10s%n",
"File", "Lines", "Code", "Comments", "Blanks", "Methods", "Complex", "Maintain");
System.out.printf("%-30s %6s %6s %6s %6s %6s %6s %10s%n",
"----", "-----", "----", "-------", "------", "-------", "-------", "--------");
for (FileMetrics fileMetric : result.getFileMetrics()) {
MetricsResult metrics = fileMetric.getMetrics();
System.out.printf("%-30s %6d %6d %6d %6d %6d %6d %9.1f%n",
truncateFileName(fileMetric.getFileName(), 30),
metrics.getLinesOfCode(),
metrics.getCodeLines(),
metrics.getCommentLines(),
metrics.getBlankLines(),
metrics.getMethodCount(),
metrics.getCyclomaticComplexity(),
fileMetric.getMaintainabilityIndex());
}
}
private static void generateCodeSmellsReport(AnalysisResult result) {
List<CodeSmell> allSmells = result.getFileMetrics().stream()
.flatMap(fm -> fm.getCodeSmells().stream())
.collect(Collectors.toList());
if (allSmells.isEmpty()) {
System.out.println("CODE SMELLS ANALYSIS");
System.out.println("====================");
System.out.println("No significant code smells detected.");
return;
}
System.out.println("CODE SMELLS DETECTED");
System.out.println("====================");
Map<String, Long> smellCounts = allSmells.stream()
.collect(Collectors.groupingBy(CodeSmell::getType, Collectors.counting()));
System.out.println("Summary by Type:");
smellCounts.forEach((type, count) ->
System.out.printf(" %s: %d occurrences%n", type, count));
System.out.println();
System.out.println("Detailed Findings:");
for (FileMetrics fileMetric : result.getFileMetrics()) {
if (!fileMetric.getCodeSmells().isEmpty()) {
System.out.println(" " + fileMetric.getFileName() + ":");
for (CodeSmell smell : fileMetric.getCodeSmells()) {
System.out.println(" - " + smell.getDescription());
}
}
}
}
private static void generateRecommendations(AnalysisResult result) {
MetricsResult total = result.getTotalMetrics();
List<String> recommendations = new ArrayList<>();
// Complexity recommendations
if (total.getAverageComplexity() > 10) {
recommendations.add("High average complexity detected. Consider refactoring complex methods.");
}
// Comment density recommendations
double commentDensity = percentage(total.getCommentLines(), total.getCommentLines() + total.getCodeLines());
if (commentDensity < 10) {
recommendations.add("Low comment density. Consider adding more documentation.");
} else if (commentDensity > 40) {
recommendations.add("High comment density. Some comments might be redundant.");
}
// Method count recommendations
double avgMethodsPerClass = (double) total.getMethodCount() / Math.max(total.getClassCount(), 1);
if (avgMethodsPerClass > 20) {
recommendations.add("Large classes detected. Consider applying Single Responsibility Principle.");
}
// Maintainability recommendations
double avgMaintainability = result.getFileMetrics().stream()
.mapToDouble(FileMetrics::getMaintainabilityIndex)
.average()
.orElse(0);
if (avgMaintainability < 65) {
recommendations.add("Low maintainability index. Code may be difficult to maintain.");
}
if (!recommendations.isEmpty()) {
System.out.println("RECOMMENDATIONS");
System.out.println("===============");
recommendations.forEach(rec -> System.out.println("• " + rec));
}
}
private static String truncateFileName(String fileName, int maxLength) {
if (fileName.length() <= maxLength) {
return fileName;
}
return "..." + fileName.substring(fileName.length() - maxLength + 3);
}
private static double percentage(int part, int total) {
if (total == 0) return 0;
return (double) part / total * 100;
}
}
// HTML Report Generator
class HTMLReportGenerator {
public static String generateHTMLReport(AnalysisResult result) {
StringBuilder html = new StringBuilder();
html.append("""
<!DOCTYPE html>
<html>
<head>
<title>Code Metrics Analysis Report</title>
<style>
body { font-family: Arial, sans-serif; margin: 20px; }
.header { background: #f0f0f0; padding: 20px; border-radius: 5px; }
.section { margin: 20px 0; }
table { border-collapse: collapse; width: 100%; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
th { background-color: #f2f2f2; }
.good { color: green; }
.warning { color: orange; }
.bad { color: red; }
.metric-card {
display: inline-block;
width: 200px;
margin: 10px;
padding: 15px;
border: 1px solid #ddd;
border-radius: 5px;
text-align: center;
}
</style>
</head>
<body>
<div class="header">
<h1>Code Metrics Analysis Report</h1>
<p>Generated on: """ + new Date() + """</p>
</div>
""");
generateHTMLSummary(html, result);
generateHTMLDetailedTable(html, result);
generateHTMLCodeSmells(html, result);
html.append("</body></html>");
return html.toString();
}
private static void generateHTMLSummary(StringBuilder html, AnalysisResult result) {
MetricsResult total = result.getTotalMetrics();
html.append("""
<div class="section">
<h2>Summary Metrics</h2>
<div class="metric-card">
<h3>Files Analyzed</h3>
<p style="font-size: 24px; font-weight: bold;">""" + result.getFileMetrics().size() + """</p>
</div>
<div class="metric-card">
<h3>Total Lines</h3>
<p style="font-size: 24px; font-weight: bold;">""" + total.getLinesOfCode() + """</p>
</div>
<div class="metric-card">
<h3>Code Lines</h3>
<p style="font-size: 24px; font-weight: bold;">""" + total.getCodeLines() + """</p>
</div>
<div class="metric-card">
<h3>Methods</h3>
<p style="font-size: 24px; font-weight: bold;">""" + total.getMethodCount() + """</p>
</div>
</div>
""");
}
private static void generateHTMLDetailedTable(StringBuilder html, AnalysisResult result) {
html.append("""
<div class="section">
<h2>Detailed File Metrics</h2>
<table>
<thead>
<tr>
<th>File</th>
<th>Lines</th>
<th>Code</th>
<th>Comments</th>
<th>Blanks</th>
<th>Methods</th>
<th>Complexity</th>
<th>Maintainability</th>
</tr>
</thead>
<tbody>
""");
for (FileMetrics fileMetric : result.getFileMetrics()) {
MetricsResult metrics = fileMetric.getMetrics();
String maintainabilityClass = getMaintainabilityClass(fileMetric.getMaintainabilityIndex());
html.append(String.format("""
<tr>
<td>%s</td>
<td>%d</td>
<td>%d</td>
<td>%d</td>
<td>%d</td>
<td>%d</td>
<td>%d</td>
<td class="%s">%.1f</td>
</tr>
""",
fileMetric.getFileName(),
metrics.getLinesOfCode(),
metrics.getCodeLines(),
metrics.getCommentLines(),
metrics.getBlankLines(),
metrics.getMethodCount(),
metrics.getCyclomaticComplexity(),
maintainabilityClass,
fileMetric.getMaintainabilityIndex()
));
}
html.append("</tbody></table></div>");
}
private static void generateHTMLCodeSmells(StringBuilder html, AnalysisResult result) {
List<CodeSmell> allSmells = result.getFileMetrics().stream()
.flatMap(fm -> fm.getCodeSmells().stream())
.collect(Collectors.toList());
if (!allSmells.isEmpty()) {
html.append("""
<div class="section">
<h2>Code Smells Detected</h2>
<ul>
""");
for (CodeSmell smell : allSmells) {
html.append("<li><strong>").append(smell.getType())
.append(":</strong> ").append(smell.getDescription()).append("</li>");
}
html.append("</ul></div>");
}
}
private static String getMaintainabilityClass(double index) {
if (index >= 85) return "good";
if (index >= 65) return "warning";
return "bad";
}
}
Main Application Class
package com.codemetrics;
import java.io.*;
import java.nio.file.*;
public class CodeMetricsApplication {
public static void main(String[] args) {
if (args.length == 0) {
System.out.println("Usage: java CodeMetricsApplication <directory-path> [--html]");
System.out.println("Example: java CodeMetricsCalculator /path/to/java/source --html");
return;
}
String directoryPath = args[0];
boolean generateHTML = args.length > 1 && "--html".equals(args[1]);
try {
CodeMetricsCalculator calculator = new CodeMetricsCalculator(directoryPath);
AnalysisResult result = calculator.analyze();
// Generate console report
MetricsReporter.generateConsoleReport(result);
// Generate HTML report if requested
if (generateHTML) {
String htmlReport = HTMLReportGenerator.generateHTMLReport(result);
Path htmlPath = Paths.get("code-metrics-report.html");
Files.write(htmlPath, htmlReport.getBytes());
System.out.println("\nHTML report generated: " + htmlPath.toAbsolutePath());
}
} catch (IOException e) {
System.err.println("Error analyzing code: " + e.getMessage());
e.printStackTrace();
} catch (Exception e) {
System.err.println("Unexpected error: " + e.getMessage());
e.printStackTrace();
}
}
}
Usage Examples
Basic Usage
// Analyze a directory
CodeMetricsCalculator calculator = new CodeMetricsCalculator("/path/to/java/project");
AnalysisResult result = calculator.analyze();
// Generate console report
MetricsReporter.generateConsoleReport(result);
// Generate HTML report
String html = HTMLReportGenerator.generateHTMLReport(result);
Files.write(Paths.get("report.html"), html.getBytes());
Programmatic Usage
// Analyze specific files
List<File> javaFiles = Arrays.asList(
new File("src/main/java/com/example/MyClass.java"),
new File("src/main/java/com/example/AnotherClass.java")
);
CodeMetricsCalculator calculator = new CodeMetricsCalculator(javaFiles);
AnalysisResult result = calculator.analyze();
// Access metrics programmatically
for (FileMetrics fileMetric : result.getFileMetrics()) {
System.out.println("File: " + fileMetric.getFileName());
System.out.println("Maintainability: " + fileMetric.getMaintainabilityIndex());
System.out.println("Complexity: " + fileMetric.getMetrics().getCyclomaticComplexity());
}
Features Summary
- Comprehensive Metrics: LOC, complexity, Halstead metrics, maintainability index
- Code Smell Detection: Identifies common anti-patterns
- Multiple Output Formats: Console and HTML reports
- Flexible Analysis: Can analyze directories or specific files
- Extensible Architecture: Easy to add new metrics and analyzers
This Code Metrics Calculator provides valuable insights into code quality and helps identify areas for improvement in Java projects.