##### Overview

- Download PMD 5.0.5
- What's new in PMD 5.0.5
- PMD in the news
- PMD-related products and books
- Best practices
- Future directions
- Similar projects
- Credits
- License
- What does 'PMD' mean?

##### Usage

- Installation
- Command line usage
- Ant task usage
- Maven plugin usage
- Mvn plugin usage
- IDE plugin usage
- Suppressing warnings
- Finding duplicated code
- JSP support

##### Customizing PMD

- Compiling PMD
- How to write a rule
- Writing XPath rules
- How to make a rule set
- How it works
- Rule guidelines
- PMD developers information
- PMD Release Process

##### For example

- Run PMD on a Sourceforge project

##### Misc.

- XPath tutorial (Gregorian)

##### Rule Sets

- ecmascript
  - Basic Ecmascript
  - Braces
  - Unnecessary
- java
  - Android
  - Basic
  - Braces
  - Clone Implementation
  - Code Size
  - Comments
  - Controversial
  - Coupling
  - Design
  - Empty Code
  - Finalizer
  - Import Statements
  - J2EE
  - JavaBeans
  - JUnit
  - Jakarta Commons Logging
  - Java Logging
  - Migration
  - Naming
  - Optimization
  - Strict Exceptions
  - String and StringBuffer
  - Security Code Guidelines
  - Type Resolution
  - Unnecessary
  - Unused Code
- jsp
  - Basic JSF
  - Basic JSP
- xml
  - Basic XML
- xsl
  - XPath in XSL

##### Project Documentation

- Project Information
- Project Reports

## Basic

The Basic ruleset contains a collection of good practices which should be followed.

### JumbledIncrementer

Since: PMD 1.0

Avoid jumbled loop incrementers - its usually a mistake, and is confusing even if intentional.

    //ForStatement
     [
      ForUpdate/StatementExpressionList/StatementExpression/PostfixExpression/PrimaryExpression/PrimaryPrefix/Name/@Image
      =
      ancestor::ForStatement/ForInit//VariableDeclaratorId/@Image
     ]

Example(s):

    public class JumbledIncrementerRule1 {
    	public void foo() {
    		for (int i = 0; i < 10; i++) {			// only references 'i'
    			for (int k = 0; k < 20; i++) {		// references both 'i' and 'k'
    				System.out.println("Hello");
    			}
    		}
    	}
    }

### ForLoopShouldBeWhileLoop

Since: PMD 1.02

Some for loops can be simplified to while loops, this makes them more concise.

    //ForStatement
     [count(*) > 1]
     [not(LocalVariableDeclaration)]
     [not(ForInit)]
     [not(ForUpdate)]
     [not(Type and Expression and Statement)]

Example(s):

    public class Foo {
    	void bar() {
    		for (;true;) true; // No Init or Update part, may as well be: while (true)
    	}
    }

### OverrideBothEqualsAndHashcode

Since: PMD 0.4

Override both public boolean Object.equals(Object other), and public int Object.hashCode(), or override neither. Even if you are inheriting a hashCode() from a parent class, consider implementing hashCode and explicitly delegating to your superclass.

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.OverrideBothEqualsAndHashcodeRule

Example(s):

    public class Bar {		// poor, missing a hashcode() method
    	public boolean equals(Object o) {
          // do some comparison
    	}
    }

    public class Baz {		// poor, missing an equals() method
    	public int hashCode() {
          // return some hash value
    	}
    }

    public class Foo {		// perfect, both methods provided
    	public boolean equals(Object other) {
          // do some comparison
    	}
    	public int hashCode() {
          // return some hash value
    	}
    }

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.

### DoubleCheckedLocking

Since: PMD 1.04

Partially created objects can be returned by the Double Checked Locking pattern when used in Java. An optimizing JRE may assign a reference to the baz variable before it creates the object the reference is intended to point to. For more details refer to: http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.DoubleCheckedLockingRule

Example(s):

    public class Foo {
    	Object baz;
    	Object bar() {
    		if (baz == null) { // baz may be non-null yet not fully created
    			synchronized(this) {
    				if (baz == null) {
    					baz = new Object();
            		}
          		}
        	}
    		return baz;
    	}
    }

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.

### ReturnFromFinallyBlock

Since: PMD 1.05

Avoid returning from a finally block, this can discard exceptions.

    //FinallyStatement//ReturnStatement

Example(s):

    public class Bar {
    	public String foo() {
    		try {
    			throw new Exception( "My Exception" );
    		} catch (Exception e) {
    			throw e;
    		} finally {
    			return "A. O. K."; // return not recommended here
    		}
    	}
    }

### UnconditionalIfStatement

Since: PMD 1.5

Do not use "if" statements whose conditionals are always true or always false.

    //IfStatement/Expression
     [count(PrimaryExpression)=1]
     /PrimaryExpression/PrimaryPrefix/Literal/BooleanLiteral

Example(s):

    public class Foo {
    	public void close() {
    		if (true) {		// fixed conditional, not recommended
    			// ...
    		}
    	}
    }

### BooleanInstantiation

Since: PMD 1.2

Avoid instantiating Boolean objects; you can reference Boolean.TRUE, Boolean.FALSE, or call Boolean.valueOf() instead.

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.BooleanInstantiationRule

Example(s):

    Boolean bar = new Boolean("true");		// unnecessary creation, just reference Boolean.TRUE;
    Boolean buz = Boolean.valueOf(false);	// ...., just reference Boolean.FALSE;

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.

### CollapsibleIfStatements

Since: PMD 3.1

Sometimes two consecutive 'if' statements can be consolidated by separating their conditions with a boolean short-circuit operator.

    //IfStatement[@Else='false']/Statement
     /IfStatement[@Else='false']
     |
    //IfStatement[@Else='false']/Statement
     /Block[count(BlockStatement)=1]/BlockStatement
      /Statement/IfStatement[@Else='false']

Example(s):

    void bar() {
    	if (x) {			// original implementation
    		if (y) {
    			// do stuff
    		}
    	}
    }

    void bar() {
    	if (x && y) {		// optimized implementation
    		// do stuff
    	}
    }

### ClassCastExceptionWithToArray

Since: PMD 3.4

When deriving an array of a specific class from your Collection, one should provide an array of the same class as the parameter of the toArray() method. Doing otherwise you will will result in a ClassCastException.

    //CastExpression[Type/ReferenceType/ClassOrInterfaceType[@Image !=
    "Object"]]/PrimaryExpression
    [
     PrimaryPrefix/Name[ends-with(@Image, '.toArray')]
     and
     PrimarySuffix/Arguments[count(*) = 0]
    and
    count(PrimarySuffix) = 1
    ]

Example(s):

    Collection c = new ArrayList();
    Integer obj = new Integer(1);
    c.add(obj);

        // this would trigger the rule (and throw a ClassCastException if executed)
    Integer[] a = (Integer [])c.toArray();

       // this is fine and will not trigger the rule
    Integer[] b = (Integer [])c.toArray(new Integer[c.size()]);

### AvoidDecimalLiteralsInBigDecimalConstructor

Since: PMD 3.4

One might assume that the result of "new BigDecimal(0.1)" is exactly equal to 0.1, but it is actually equal to .1000000000000000055511151231257827021181583404541015625. This is because 0.1 cannot be represented exactly as a double (or as a binary fraction of any finite length). Thus, the long value that is being passed in to the constructor is not exactly equal to 0.1, appearances notwithstanding. The (String) constructor, on the other hand, is perfectly predictable: 'new BigDecimal("0.1")' is exactly equal to 0.1, as one would expect. Therefore, it is generally recommended that the (String) constructor be used in preference to this one.

    //AllocationExpression[ClassOrInterfaceType[@Image="BigDecimal"]
    and
    ./Arguments/ArgumentList
    /Expression/PrimaryExpression/PrimaryPrefix/Literal[(not
    (ends-with
    (@Image,'"'))) and contains(@Image,".")]]

Example(s):

    BigDecimal bd = new BigDecimal(1.123);		// loss of precision, this would trigger the rule

    BigDecimal bd = new BigDecimal("1.123");   	// preferred approach

    BigDecimal bd = new BigDecimal(12);     	// preferred approach, ok for integer values

### MisplacedNullCheck

Since: PMD 3.5

The null check here is misplaced. If the variable is null a NullPointerException will be thrown. Either the check is useless (the variable will never be "null") or it is incorrect.

    //Expression
        /*[self::ConditionalOrExpression or self::ConditionalAndExpression]
        /descendant::PrimaryExpression/PrimaryPrefix
        /Name[starts-with(@Image,
            concat(ancestor::PrimaryExpression/following-sibling::EqualityExpression
                [./PrimaryExpression/PrimaryPrefix/Literal/NullLiteral]
                /PrimaryExpression/PrimaryPrefix
                /Name[count(../../PrimarySuffix)=0]/@Image,".")
            )
         ]
         [count(ancestor::ConditionalAndExpression/EqualityExpression
                [@Image='!=']
                [./PrimaryExpression/PrimaryPrefix/Literal/NullLiteral]
                [starts-with(following-sibling::*/PrimaryExpression/PrimaryPrefix/Name/@Image,
                    concat(./PrimaryExpression/PrimaryPrefix/Name/@Image, '.'))]
          ) = 0
         ]

Example(s):

    public class Foo {
    	void bar() {
    		if (a.equals(baz) && a != null) {}
    		}
    }

Example(s):

    public class Foo {
    	void bar() {
    		if (a.equals(baz) || a == null) {}
    	}
    }

### AvoidThreadGroup

Since: PMD 3.6

Avoid using java.lang.ThreadGroup; although it is intended to be used in a threaded environment it contains methods that are not thread-safe.

    //AllocationExpression/ClassOrInterfaceType[pmd-java:typeof(@Image, 'java.lang.ThreadGroup')]|
    //PrimarySuffix[contains(@Image, 'getThreadGroup')]

Example(s):

    public class Bar {
    	void buz() {
    		ThreadGroup tg = new ThreadGroup("My threadgroup") ;
    		tg = new ThreadGroup(tg, "my thread group");
    		tg = Thread.currentThread().getThreadGroup();
    		tg = System.getSecurityManager().getThreadGroup();
    	}
    }

### BrokenNullCheck

Since: PMD 3.8

The null check is broken since it will throw a NullPointerException itself. It is likely that you used || instead of && or vice versa.

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.BrokenNullCheckRule

Example(s):

    public String bar(String string) {
      // should be &&
    	if (string!=null || !string.equals(""))
    		return string;
      // should be ||
    	if (string==null && string.equals(""))
    		return string;
    }

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.

### BigIntegerInstantiation

Since: PMD 3.9

Don't create instances of already existing BigInteger (BigInteger.ZERO, BigInteger.ONE) and for Java 1.5 onwards, BigInteger.TEN and BigDecimal (BigDecimal.ZERO, BigDecimal.ONE, BigDecimal.TEN)

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.BigIntegerInstantiationRule

Example(s):

    BigInteger bi = new BigInteger(1);		// reference BigInteger.ONE instead
    BigInteger bi2 = new BigInteger("0");	// reference BigInteger.ZERO instead
    BigInteger bi3 = new BigInteger(0.0);	// reference BigInteger.ZERO instead
    BigInteger bi4;
    bi4 = new BigInteger(0);				// reference BigInteger.ZERO instead

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.

### AvoidUsingOctalValues

Since: PMD 3.9

Integer literals should not start with zero since this denotes that the rest of literal will be interpreted as an octal value.

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.AvoidUsingOctalValuesRule

Example(s):

    int i = 012;	// set i with 10 not 12
    int j = 010;	// set j with 8 not 10
    k = i * j;		// set k with 80 not 120

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.
strict | false | Detect violations between 00 and 07

### AvoidUsingHardCodedIP

Since: PMD 4.1

Application with hard-coded IP addresses can become impossible to deploy in some cases. Externalizing IP adresses is preferable.

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.AvoidUsingHardCodedIPRule

Example(s):

    public class Foo {
    	private String ip = "127.0.0.1"; 	// not recommended
    }

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
pattern | ^"[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}"$ | Regular Expression
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.
checkAddressTypes | [IPv4, IPv6, IPv4 mapped IPv6] | Check for IP address types.

### CheckResultSet

Since: PMD 4.1

Always check the return values of navigation methods (next, previous, first, last) of a ResultSet. If the value return is 'false', it should be handled properly.

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.CheckResultSetRule

Example(s):

    Statement stat = conn.createStatement();
    ResultSet rst = stat.executeQuery("SELECT name FROM person");
    rst.next(); 	// what if it returns false? bad form
    String firstName = rst.getString(1);

    Statement stat = conn.createStatement();
    ResultSet rst = stat.executeQuery("SELECT name FROM person");
    if (rst.next()) {	// result is properly examined and used
        String firstName = rst.getString(1);
    	} else  {
    		// handle missing data
    }

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.

### AvoidMultipleUnaryOperators

Since: PMD 4.2

The use of multiple unary operators may be problematic, and/or confusing. Ensure that the intended usage is not a bug, or consider simplifying the expression.

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.AvoidMultipleUnaryOperatorsRule

Example(s):

    // These are typo bugs, or at best needlessly complex and confusing:
    int i = - -1;
    int j = + - +1;
    int z = ~~2;
    boolean b = !!true;
    boolean c = !!!true;

    // These are better:
    int i = 1;
    int j = -1;
    int z = 2;
    boolean b = true;
    boolean c = false;

    // And these just make your brain hurt:
    int i = ~-2;
    int j = -~7;

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.

### ExtendsObject

Since: PMD 5.0

No need to explicitly extend Object.

    //ExtendsList/ClassOrInterfaceType[@Image='Object' or @Image='java.lang.Object']

Example(s):

    public class Foo extends Object { 	// not required
    }

### CheckSkipResult

Since: PMD 5.0

The skip() method may skip a smaller number of bytes than requested. Check the returned value to find out if it was the case or not.

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.CheckSkipResultRule

Example(s):

    public class Foo {

       private FileInputStream _s = new FileInputStream("file");

       public void skip(int n) throws IOException {
          _s.skip(n); // You are not sure that exactly n bytes are skipped
       }

       public void skipExactly(int n) throws IOException {
          while (n != 0) {
             long skipped = _s.skip(n);
             if (skipped == 0)
                throw new EOFException();
             n -= skipped;
          }
       }

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.

### AvoidBranchingStatementAsLastInLoop

Since: PMD 5.0

Using a branching statement as the last part of a loop may be a bug, and/or is confusing. Ensure that the usage is not a bug, or consider using another approach.

This rule is defined by the following Java class: net.sourceforge.pmd.lang.java.rule.basic.AvoidBranchingStatementAsLastInLoopRule

Example(s):

      // unusual use of branching statement in a loop
    for (int i = 0; i < 10; i++) {
    	if (i*i <= 25) {
    		continue;
    	}
    	break;
    }

      // this makes more sense...
    for (int i = 0; i < 10; i++) {
    	if (i*i > 25) {
    		break;
    	}
    }

This rule has the following properties:

Name | Default Value | Description
--- | --- | ---
violationSuppressRegex |  | Suppress violations with messages matching a regular expression
violationSuppressXPath |  | Suppress violations on nodes which match a given relative XPath expression.
checkReturnLoopTypes | [for, do, while] | Check for return statements in loop types
checkContinueLoopTypes | [for, do, while] | Check for continue statements in loop types
checkBreakLoopTypes | [for, do, while] | Check for break statements in loop types

### DontCallThreadRun

Since: PMD 4.3

Explicitly calling Thread.run() method will execute in the caller's thread of control. Instead, call Thread.start() for the intended behavior.

    //StatementExpression/PrimaryExpression
    [
        PrimaryPrefix
        [
            ./Name[ends-with(@Image, '.run') or @Image = 'run']
            and substring-before(Name/@Image, '.') =//VariableDeclarator/VariableDeclaratorId/@Image
            [../../../Type/ReferenceType[ClassOrInterfaceType/@Image = 'Thread']]
            or (
            ./AllocationExpression/ClassOrInterfaceType[@Image = 'Thread']
            and ../PrimarySuffix[@Image = 'run'])
        ]
    ]

Example(s):

    Thread t = new Thread();
    t.run();            // use t.start() instead
    new Thread().run(); // same violation

### DontUseFloatTypeForLoopIndices

Since: PMD 4.3

Don't use floating point for loop indices. If you must use floating point, use double unless you're certain that float provides enough precision and you have a compelling performance need (space or time).

    //ForStatement/ForInit/LocalVariableDeclaration
    /Type/PrimitiveType[@Image="float"]

Example(s):

    public class Count {
      public static void main(String[] args) {
        final int START = 2000000000;
        int count = 0;
        for (float f = START; f < START + 50; f++)
          count++;
          //Prints 0 because (float) START == (float) (START + 50).
          System.out.println(count);
          //The termination test misbehaves due to floating point granularity.
        }
    }