Open Source Code Analyzers in Java

Suite of tools for analyzing compiled Java code: extracts dependency graphs and OO metrics from class files, computes API differences between versions. No source needed. Includes Swing and CLI interfaces and XSL output.

Extensible software model checker for Java bytecode. Acts as a JVM that systematically explores execution paths to find deadlocks, unhandled exceptions, and other defects; reports full paths to failures. Well-suited to concurrency bugs in multithreaded code.

Library to analyze, rewrite, and transform Java source code. Parses code into a full AST with analysis and transformation API; supports Java up to 20. Used for validation, conventions, and program transformation; Maven and Gradle plugins.

Development tool to enforce Java coding standards. Checks class and method design, code layout, and formatting; highly configurable with built-in Sun and Google style guides. Includes Ant task and CLI; integrates with Maven, Gradle, Eclipse, IntelliJ, Jenkins, and other IDEs and CI tools.

Extensible cross-language static code analyzer. Finds common flaws: unused variables, empty catch blocks, duplicate code, and 400+ built-in rules. Supports Java, Apex, and 16+ languages; includes CPD (copy-paste detector).

Static analysis tool that finds bugs in Java code using 400+ bug patterns. Runs on JRE 11+ and analyzes programs compiled for any Java version. Integrations for Ant, Maven, Gradle, and Eclipse; extensible via plugins (e.

Continuous code quality and security platform (SonarQube). Static analysis for 35+ languages; quality metrics, security hotspots, and technical debt. Integrates with CI/CD and IDEs; community edition and commercial options.

Analyses static class and package dependencies; finds cycles; dependency checker enforces architectural rules (e. g. layering); Ant task and CLI.

Checks Java libraries for binary and source compatibility between two JAR sets; reports API changes; Ant task can fail the build on incompatibilities.

Finds and removes duplicated Java code automatically where safe. Works on source (parser-based) or class files (BCEL). Aims to go beyond detection and refactor duplicates.

Analyzes Java code and documentation: finds oversights, errors, and common mistakes that javadoc does not. Covers documentation verification, statistics generation, and syntax analysis.

Open-source Java code review tool with 100+ inspectors: EJB compliance, threading issues, coding standards, and other quality checks. Ant task for automated review.

Dependency management for JAR files: analyzes JARs in a directory and reports dependencies. Outputs XML (with HTML stylesheet) and GraphViz DOT for diagrams. Includes afferent/efferent coupling, abstractness, instability, distance; Ant task available.

Checks Java source against configurable coding standards and potential bugs. Covers naming, layout (field/method order by visibility or type), whitespace, braces, JavaDoc. Detects empty catch/finally, switch without default, and similar issues.

Javadoc doclet that generates an HTML report of API differences between two versions: packages, classes, constructors, methods, and fields added, removed, or changed, with documentation. Compares only the API surface, not runtime behavior.

Checks Java bytecode for bugs, inconsistencies, and synchronization problems using data flow analysis and lock graph construction. Fast even on large projects; no class file modification required.

Build-time architectural rule checker for Java. Model project structure and good-practice rules in a configurable rules file; Macker enforces them during the build. Flexible and project-specific.

Consolidates QA tool data (Checkstyle, PMD, FindBugs, Cobertura, Simian) into one view and tracks trends over time. Charts violations and coverage per file or project; integrates with Maven and Ant.

Software inspection tool for Java: 200+ rules for coding standards, language misuse, best practices, structure, and potential bugs. Descriptive patterns with solutions; Eclipse, JBuilder, JDeveloper, and Ant integrations.

Eclipse plugin to find unnecessary (dead) public Java code and suggest visibility changes (protected, default, private) or final. Detects cyclic dependencies; QuickFixes for markers. Requires Eclipse >= 3.

Extensible code report tool that produces HTML/SVG reports of system state and evolution over time. Aggregates results from DependencyFinder, JDepend, PMD, CPD, JavaNCSS, Cobertura, Checkstyle, JUnit; Ant and Maven support.

Eclipse plugin for auto-arranging dependency analysis; visual feedback on dependency quality.

Static analysis of physical dependencies in a codebase. Validates structure (classes, packages, subsystems, layers), detects cycles, and computes quality metrics with configurable thresholds. Supports Java and C++.

Scans directories recursively for JAR files and generates linked, formatted HTML reports. Helps get an overview of a project or its dependencies (versions, manifests, class locations).

Traverses Java class file directories and generates design quality metrics per package. Measures extensibility, reusability, and maintainability; helps manage and control package dependencies.