Either log or rethrow this exception.

Replace the synchronized class "StringBuffer" by an unsynchronized one such as "StringBuilder".

ArrayList or LinkedList instead of Vector

Deque instead of Stack

HashMap instead of Hashtable

StringBuilder instead of StringBuffer

Remove this useless assignment to local variable xxx

This block of commented-out lines of code should be removed.

Add the "@Override" annotation above this method signature

Refactor this code to not nest more than 3 if/for/while/switch/try statements.

if (condition1) {                  // Compliant - depth = 1

/* ... */

if (condition2) {                // Compliant - depth = 2

/* ... */

for(int i = 0; i < 10; i++) {  // Compliant - depth = 3, not exceeding the limit

/* ... */

if (condition4) {            // Noncompliant - depth = 4

if (condition5) {          // Depth = 5, exceeding the limit, but issues are only reported on depth = 4

/* ... */

}

return;

}

}

}

}

The Cyclomatic Complexity of this method xxx is 11 which is greater than 10 authorized.

Merge this if statement with the enclosing one.

if (file != null) {

if (file.isFile() || file.isDirectory()) {

/* ... */

}

}

if (file != null && isFileOrDirectory(file)) {

/* ... */

}

private static boolean isFileOrDirectory(File file) {

return file.isFile() || file.isDirectory();

}

Use isEmpty() to check whether the collection is empty or not.

if (myCollection.size() == 0) {  // Noncompliant

/* ... */

}

if (myCollection.isEmpty()) {    // Compliant

/* ... */

}

Use "Long.toString" instead.

int myInt = 4;

String myIntString = new Integer(myInt).toString(); // Noncompliant; creates & discards an Integer object

myIntString = Integer.valueOf(myInt).toString(); // Noncompliant

myIntString = 4 + "";  // Noncompliant

int myInt = 4;

String myIntString = Integer.toString(myInt);

Use "BigDecimal.valueOf" instead.

double d = 1.1;

BigDecimal bd1 = new BigDecimal(d); // Noncompliant; see comment above

BigDecimal bd2 = new BigDecimal(1.1); // Noncompliant; same result

double d = 1.1;

BigDecimal bd1 = BigDecimal.valueOf(d);

BigDecimal bd2 = BigDecimal.valueOf(1.1);

Use isEmpty() to check whether the collection is empty or not.

class MyClass {

public String name;

public MyClass(String name) {

name = name;                    // Noncompliant - useless identity assignment

}

public int add(int a, int b) {

a = a + b;                      // Noncompliant

/* additional logic */

return a;                       // Seems like the parameter is returned as is, what is the point?

}

public static void main(String[] args) {

MyClass foo = new MyClass();

int a = 40;

int b = 2;

foo.add(a, b);                  // Variable "a" will still hold 40 after this call

}

}

class MyClass {

public String name;

public MyClass(String name) {

this.name = name;               // Compliant

}

public int add(int a, int b) {

return a + b;                   // Compliant

}

public static void main(String[] args) {

MyClass foo = new MyClass();

int a = 40;

int b = 2;

foo.add(a, b);

}

}}

Use "Integer.parseInt" for this string-to-int conversion

String myNum = "12.2";

float f = new Float(myNum).floatValue();  // Noncompliant; creates & discards a Float

String myNum = "12.2";

float f = Float.parseFloat(myNum);

Replace this usage of System.out or System.err by a logger.

System.out.println("My Message");  // Noncompliant

logger.info("My Message");

Move the "0" string literal on the left side of this string comparison.

String myString = null;

System.out.println("Equal? " + myString.equals("foo"));                        // Noncompliant - will raise a NPE

System.out.println("Equal? " + (myString != null && myString.equals("foo")));  // Noncompliant - null check could be removed

System.out.println("Equal?" + "foo".equals(myString));                         // Compliant - properly deals with the null case