Basic

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

 
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");
			}
		}
	}
}
 
     

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

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

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

  
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;
	}
}
 
      

//FinallyStatement//ReturnStatement

              

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

      

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

                

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

      

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

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

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

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

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

    

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()]);

  

//AllocationExpression
[ClassOrInterfaceType[@Image="BigDecimal"]]
[Arguments/ArgumentList/Expression/PrimaryExpression/PrimaryPrefix
    [
        Literal[(not(ends-with(@Image,'"'))) and contains(@Image,".")]
        or
        Name[ancestor::Block/BlockStatement/LocalVariableDeclaration
                [Type[PrimitiveType[@Image='double' or @Image='float']
                      or ReferenceType/ClassOrInterfaceType[@Image='Double' or @Image='Float']]]
                /VariableDeclarator/VariableDeclaratorId/@Image = @Image
            ]
        or
        Name[ancestor::MethodDeclaration/MethodDeclarator/FormalParameters/FormalParameter
                [Type[PrimitiveType[@Image='double' or @Image='float']
                      or ReferenceType/ClassOrInterfaceType[@Image='Double' or @Image='Float']]]
                /VariableDeclaratorId/@Image = @Image
            ]
    ]
]
 
    

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

  

    
//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
     ]
    
        

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

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

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

        

    
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();
	}
}
    
      

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

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

  

		    
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
		    
    

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

            
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
}
            
        

            
// 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;
            
        

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

    
public class Foo extends Object { 	// not required
}
    
    

        
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;
      }
   }
        
        

            
  // 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;
	}
}
            
        

//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'])
    ]
]

         

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

      

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

       

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.
    }
}