Optimization Rules

These rules deal with different optimizations that generally apply to performance best practices.

LocalVariableCouldBeFinal

A local variable assigned only once can be declared final.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.optimization.LocalVariableCouldBeFinal

Here's an example of code that would trigger this rule:

			
  
public class Bar {
 public void foo () {
  String a = "a"; //if a will not be assigned again it is better to do this:
  final String b = "b";
 }
}

MethodArgumentCouldBeFinal

A method argument that is never assigned can be declared final.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.optimization.MethodArgumentCouldBeFinal

Here's an example of code that would trigger this rule:

			
  
public void foo (String param) {
  // do stuff with param never assigning it
  // better: public void foo (final String param) {
}

AvoidInstantiatingObjectsInLoops

Detects when a new object is created inside a loop

This rule is defined by the following Java class: net.sourceforge.pmd.rules.optimization.AvoidInstantiatingObjectsInLoops

Here's an example of code that would trigger this rule:

			

public class Something {
  public static void main( String as[] ) {  
    for (int i = 0; i < 10; i++) {
      Foo f = new Foo(); //Avoid this whenever you can it's really expensive
    }
  }
}

UseArrayListInsteadOfVector

ArrayList is a much better Collection implementation than Vector.

This rule is defined by the following XPath expression:


//AllocationExpression
 /ClassOrInterfaceType[@Image='Vector' or @Image='java.util.Vector']

Here's an example of code that would trigger this rule:

			

public class SimpleTest extends TestCase {
 public void testX() {
  Collection c = new Vector();
  // This achieves the same with much better performance
  // Collection c = new ArrayList();
 }
}

SimplifyStartsWith

Since it passes in a literal of length 1, this call to String.startsWith can be rewritten using String.charAt(0) to save some time.

This rule is defined by the following XPath expression:


//PrimaryExpression
 [PrimaryPrefix/Name
  [ends-with(@Image, '.startsWith')]]
 [PrimarySuffix/Arguments/ArgumentList
  /Expression/PrimaryExpression/PrimaryPrefix
  /Literal
   [string-length(@Image)=3]
   [starts-with(@Image, '"')]
   [ends-with(@Image, '"')]
 ]

Here's an example of code that would trigger this rule:

			
  
public class Foo {
  boolean checkIt(String x) {
      return x.startsWith("a");
  }
}

UseStringBufferForStringAppends

Finds usages of += for appending strings.

This rule is defined by the following XPath expression:

                      
//StatementExpression
    [PrimaryExpression/PrimaryPrefix/Name
        [@Image = ancestor::MethodDeclaration//LocalVariableDeclaration
            [./Type//ClassOrInterfaceType[@Image =
'String']]/VariableDeclarator/VariableDeclaratorId/@Image]]
    //AssignmentOperator[@Compound='true']

Here's an example of code that would trigger this rule:

			
      
public class Foo {
 void bar() {
  String a;
  a = "foo";
  a += " bar";
  // better would be:
  // StringBuffer a = new StringBuffer("foo");
  // a.append(" bar);
 }
}