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,"."))
    ]
    
        
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 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 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.

		        	
//Type/ReferenceType/ClassOrInterfaceType[
        (@Image = 'ResultSet')
        and
        (../../../descendant::Name[ends-with(@Image,'executeQuery')])
        and
        (
	(not (contains(
                        (./ancestor::Block/descendant::WhileStatement/descendant::Name/attribute::Image),
                        concat(../../../VariableDeclarator/VariableDeclaratorId/attribute::Image,'.next')
		)  ) )
	and ( not ( contains(
                        (./ancestor::Block/descendant::IfStatement/descendant::Name/attribute::Image),
                        concat(../../../VariableDeclarator/VariableDeclaratorId/attribute::Image,'.next')
		) ) )
	and (not (contains(
                        (./ancestor::Block/descendant::WhileStatement/descendant::Name/attribute::Image),
                        concat(../../../VariableDeclarator/VariableDeclaratorId/attribute::Image,'.previous')
		)  ) )
	and ( not ( contains(
                        (./ancestor::Block/descendant::IfStatement/descendant::Name/attribute::Image),
                        concat(../../../VariableDeclarator/VariableDeclaratorId/attribute::Image,'.previous')
		) ) )
	and ( not ( contains(
                        (./ancestor::Block/descendant::IfStatement/descendant::Name/attribute::Image),
                        concat(../../../VariableDeclarator/VariableDeclaratorId/attribute::Image,'.last')
		) ) )
	and ( not ( contains(
                        (./ancestor::Block/descendant::IfStatement/descendant::Name/attribute::Image),
                        concat(../../../VariableDeclarator/VariableDeclaratorId/attribute::Image,'.first')
		) ) )

         )
]
		        	
            	
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
}
            
        

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 Check for return statements in loop types
checkContinueLoopTypes Check for continue statements in loop types
checkBreakLoopTypes 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.
    }
}