This list may grow each year with either new versions or patches. Enjoy!
Following is an example related to the usage of the various ignore capabilities.
@SuppressWarnings("MagicCharacter")
@SuppressWarnings("AssertStatement")
@SuppressWarnings("AwaitWithoutCorrespondingSignal")
Warning Description - Warning Name
"Magic character" MagicCharacter
"Magic number" MagicNumber
'Comparator.compare()' method does not use parameter ComparatorMethodParameterNotUsed
'Connection.prepare*()' call with non-constant string JDBCPrepareStatementWithNonConstantString
'Iterator.hasNext()' which calls 'next()' IteratorHasNextCallsIteratorNext
'Iterator.next()' which can't throw 'NoSuchElementException' IteratorNextCanNotThrowNoSuchElementException
'Statement.execute()' call with non-constant string JDBCExecuteWithNonConstantString
'String.equals("")' StringEqualsEmptyString
'StringBuffer' may be 'StringBuilder' (JDK 5.0 only) StringBufferMayBeStringBuilder
'StringBuffer.toString()' in concatenation StringBufferToStringInConcatenation
'assert' statement AssertStatement
'assertEquals()' between objects of inconvertible types AssertEqualsBetweenInconvertibleTypes
'await()' not in loop AwaitNotInLoop
'await()' without corresponding 'signal()' AwaitWithoutCorrespondingSignal
'break' statement BreakStatement
'break' statement with label BreakStatementWithLabel
'catch' generic class CatchGenericClass
'clone()' does not call 'super.clone()' CloneDoesntCallSuperClone
'clone()' does not declare 'CloneNotSupportedException' CloneDoesntDeclareCloneNotSupportedException
'clone()' instantiates objects with constructor CloneCallsConstructors
'clone()' method in non-Cloneable class CloneInNonCloneableClass
'compareto()' instead of 'compareTo()' MisspelledCompareTo
'continue' or 'break' inside 'finally' block ContinueOrBreakFromFinallyBlock
'continue' statement ContinueStatement
'continue' statement with label ContinueStatementWithLabel
'default' not last case in 'switch' DefaultNotLastCaseInSwitch
'equal()' instead of 'equals()' MisspelledEquals
'equals()' between objects of inconvertible types EqualsBetweenInconvertibleTypes
'equals()' called on array type ArrayEquals
'equals()' called on java.math.BigDecimal BigDecimalEquals
'equals()' method which does not check class of parameter EqualsWhichDoesntCheckParameterClass
'equals()' or 'hashCode()' called on java.net.URL object EqualsHashCodeCalledOnUrl
'final' class FinalClass
'final' method FinalMethod
'final' method in 'final' class FinalMethodInFinalClass
'finalize()' called explicitly FinalizeCalledExplicitly
'finalize()' declaration FinalizeDeclaration
'finalize()' does not call 'super.finalize()' FinalizeDoesntCallSuperFinalize
'finalize()' not declared 'protected' FinalizeNotProtected
'finally' block which can not complete normally finally
'for' loop may be replaced by 'while' loop ForLoopReplaceableByWhile
'for' loop replaceable by 'for each' ForLoopReplaceableByForEach
'for' loop where update or condition does not use loop variable ForLoopThatDoesntUseLoopVariable
'for' loop with missing components ForLoopWithMissingComponent
'hashcode()' instead of 'hashCode()' MisspelledHashcode
'if' statement with identical branches IfStatementWithIdenticalBranches
'if' statement with negated condition IfStatementWithNegatedCondition
'if' statement with too many branches IfStatementWithTooManyBranches
'indexOf()' expression is replaceable by 'contains()' ListIndexOfReplaceableByContains
'instanceof' a concrete class InstanceofInterfaces
'instanceof' check for 'this' InstanceofThis
'instanceof' on 'catch' parameter InstanceofCatchParameter
'instanceof' with incompatible interface InstanceofIncompatibleInterface
'notify()' or 'notifyAll()' called on java.util.concurrent.locks.Condition object NotifyCalledOnCondition
'notify()' or 'notifyAll()' while not synced NotifyNotInSynchronizedContext
'notify()' or 'notifyAll()' without corresponding state change NakedNotify
'notify()' without corresponding 'wait()' NotifyWithoutCorrespondingWait
'private' method declared 'final' FinalPrivateMethod
'protected' member in 'final' class ProtectedMemberInFinalClass
'public' constructor in non-public class PublicConstructorInNonPublicClass
'readObject()' or 'writeObject()' not declared 'private' NonPrivateSerializationMethod
'readResolve()' or 'writeReplace()' not declared 'protected' ReadResolveAndWriteReplaceProtected
'return' inside 'finally' block ReturnInsideFinallyBlock
'serialPersistentFields' field not declared 'private static final ObjectStreamField[]' SerialPersistentFieldsWithWrongSignature
'serialVersionUID' field not declared 'private static final long' SerialVersionUIDWithWrongSignature
'setUp()' does not call 'super.setUp()' SetUpDoesntCallSuperSetUp
'setUp()' with incorrect signature SetUpWithIncorrectSignature
'setup()' instead of 'setUp()' MisspelledSetUp
'signal()' without corresponding 'await()' SignalWithoutCorrespondingAwait
'size() == 0' replaceable by 'isEmpty()' SizeReplaceableByIsEmpty
'static' method declared 'final' FinalStaticMethod
'static', non-'final' field StaticNonFinalField
'suite()' method not declared 'static' SuiteNotDeclaredStatic
'switch' statement SwitchStatement
'switch' statement with too few branches SwitchStatementWithTooFewBranches
'switch' statement with too low of a branch density SwitchStatementDensity
'switch' statement with too many branches SwitchStatementWithTooManyBranches
'switch' statement without 'default' branch SwitchStatementWithoutDefaultBranch
'synchronized' method SynchronizedMethod
'tearDown()' does not call 'super.tearDown()' TearDownDoesntCallSuperTearDown
'tearDown()' with incorrect signature TearDownWithIncorrectSignature
'teardown()' instead of 'tearDown()' MisspelledTearDown
'this' reference escaped in object construction ThisEscapedInObjectConstruction
'throw' caught by containing 'try' statement ThrowCaughtLocally
'throw' inside 'catch' block which ignores the caught exception ThrowInsideCatchBlockWhichIgnoresCaughtException
'throw' inside 'finally' block ThrowFromFinallyBlock
'tostring()' instead of 'toString()' MisspelledToString
'wait()' called on java.util.concurrent.locks.Condition object WaitCalledOnCondition
'wait()' not in loop WaitNotInLoop
'wait()' or 'await()' without timeout WaitOrAwaitWithoutTimeout
'wait()' while holding two locks WaitWhileHoldingTwoLocks
'wait()' while not synced WaitWhileNotSynced
'wait()' without corresponding 'notify()' WaitWithoutCorrespondingNotify
'while' loop replaceable by 'for each' WhileLoopReplaceableByForEach
* import OnDemandImport
Abstract class extends concrete class AbstractClassExtendsConcreteClass
Abstract class which has no concrete subclass AbstractClassNeverImplemented
Abstract class which has only one direct inheritor AbstractClassWithOnlyOneDirectInheritor
Abstract class without abstract methods AbstractClassWithoutAbstractMethods
Abstract method call in constructor AbstractMethodCallInConstructor
Abstract method overrides abstract method AbstractMethodOverridesAbstractMethod
Abstract method overrides concrete method AbstractMethodOverridesConcreteMethod
Abstract method with missing implementations AbstractMethodWithMissingImplementations
Access of system properties AccessOfSystemProperties
Access to non thread-safe static field from instance AccessToNonThreadSafeStaticFieldFromInstance
Access to static field locked on instance data AccessToStaticFieldLockedOnInstance
Accessing a non-public field of another object AccessingNonPublicFieldOfAnotherObject
Annotation Annotation
Annotation class AnnotationClass
Annotation naming convention AnnotationNamingConvention
Anonymous class variable hides variable in containing method AnonymousClassVariableHidesContainingMethodVariable
Anonymous inner class AnonymousInnerClass
Anonymous inner class may be a named static inner class AnonymousInnerClassMayBeStatic
Anonymous inner class with too many methods AnonymousInnerClassWithTooManyMethods
Arithmetic operation on volatile field ArithmeticOnVolatileField
Array.length in loop condition ArrayLengthInLoopCondition
Assignment replaceable with operator assignment AssignmentReplaceableWithOperatorAssignment
Assignment to 'for' loop parameter AssignmentToForLoopParameter
Assignment to 'null' AssignmentToNull
Assignment to Collection or array field from parameter AssignmentToCollectionOrArrayFieldFromParameter
Assignment to Date or Calendar field from parameter AssignmentToDateFieldFromParameter
Assignment to catch block parameter AssignmentToCatchBlockParameter
Assignment to method parameter AssignmentToMethodParameter
Assignment to static field from instance method AssignmentToStaticFieldFromInstanceMethod
Assignment used as condition AssignmentUsedAsCondition
Auto-boxing AutoBoxing
Auto-unboxing AutoUnboxing
Boolean constructor call BooleanConstructorCall
Boolean method name must start with question word BooleanMethodNameMustStartWithQuestion
Busy wait BusyWait
C-style array declaration CStyleArrayDeclaration
Call to 'Collection.toArray()' with zero-length array argument ToArrayCallWithZeroLengthArrayArgument
Call to 'Date.toString()' CallToDateToString
Call to 'Runtime.exec()' CallToRuntimeExecWithNonConstantString
Call to 'String.compareTo()' CallToStringCompareTo
Call to 'String.concat()' can be replaced by '+' CallToStringConcatCanBeReplacedByOperator
Call to 'String.equals()' CallToStringEquals
Call to 'String.equalsIgnoreCase()' CallToStringEqualsIgnoreCase
Call to 'String.toUpperCase()' or 'toLowerCase()' without a Locale StringToUpperCaseOrToLowerCaseWithoutLocale
Call to 'System.exit()' or related methods CallToSystemExit
Call to 'System.getenv()' CallToSystemGetenv
Call to 'System.loadLibrary()' with non-constant string LoadLibraryWithNonConstantString
Call to 'System.runFinalizersOnExit()' CallToSystemRunFinalizersOnExit
Call to 'System.setSecurityManager()' CallToSystemSetSecurityManager
Call to 'Thread.dumpStack()' CallToThreadDumpStack
Call to 'Thread.run()' CallToThreadRun
Call to 'Thread.setPriority()' CallToThreadSetPriority
Call to 'Thread.sleep()' while synchronized SleepWhileHoldingLock
Call to 'Thread.start()' during object construction CallToThreadStartDuringObjectConstruction
Call to 'Thread.stop()', 'suspend()' or 'resume()' CallToThreadStopSuspendOrResumeManager
Call to 'Thread.yield()' CallToThreadYield
Call to 'Time.toString()' CallToTimeToString
Call to 'intern()' on String constant ConstantStringIntern
Call to 'notify()' instead of 'notifyAll()' CallToNotifyInsteadOfNotifyAll
Call to 'printStackTrace()' CallToPrintStackTrace
Call to 'signal()' instead of 'signalAll()' CallToSignalInsteadOfSignalAll
Call to Numeric 'toString()' CallToNumericToString
Call to String.replaceAll(".", ...) ReplaceAllDot
Call to a native method while locked CallToNativeMethodWhileLocked
Call to default 'toString()' ObjectToString
Call to simple getter from within class CallToSimpleGetterFromWithinClass
Call to simple setter from within class CallToSimpleSetterFromWithinClass
Calls to 'System.gc()' or 'Runtime.gc()' CallToSystemGC
Cast conflicts with 'instanceof' CastConflictsWithInstanceof
Cast to a concrete class CastToConcreteClass
Casting to incompatible interface CastToIncompatibleInterface
Caught exception is immediately rethrown CaughtExceptionImmediatelyRethrown
Chain of 'instanceof' checks ChainOfInstanceofChecks
Chained equality comparisons ChainedEqualityComparisons
Chained method calls ChainedMethodCall
Channel opened but not safely closed ChannelOpenedButNotSafelyClosed
Character comparison CharacterComparison
Checked exception class CheckedExceptionClass
Class escapes defined scope ClassEscapesDefinedScope
Class explicitly extends a Collection class ClassExtendsConcreteCollection
Class explicitly extends java.lang.Object ClassExplicitlyExtendsObject
Class explicitly extends java.lang.Thread ClassExplicitlyExtendsThread
Class extends annotation interface ClassExplicitlyAnnotation
Class extends utility class ExtendsUtilityClass
Class may be interface ClassMayBeInterface
Class name differs from file name ClassNameDiffersFromFileName
Class name prefixed with package name ClassNamePrefixedWithPackageName
Class name same as ancestor name ClassNameSameAsAncestorName
Class naming convention ClassNamingConvention
Class references one of its subclasses ClassReferencesSubclass
Class too deep in inheritance tree ClassTooDeepInInheritanceTree
Class with multiple loggers ClassWithMultipleLoggers
Class with too many constructors ClassWithTooManyConstructors
Class with too many fields ClassWithTooManyFields
Class with too many methods ClassWithTooManyMethods
Class without 'toString()' ClassWithoutToString
Class without constructor ClassWithoutConstructor
Class without logger ClassWithoutLogger
Class without no-arg constructor ClassWithoutNoArgConstructor
Class without package statement ClassWithoutPackageStatement
ClassLoader instantiation ClassLoaderInstantiation
Cloneable class in secure context CloneableClassInSecureContext
Cloneable class without 'clone()' CloneableClassWithoutClone
Collection added to self CollectionAddedToSelf
Collection declared by class, not interface CollectionDeclaredAsConcreteClass
Collection without initial capacity CollectionWithoutInitialCapacity
Comparable implemented but 'equals()' not overridden ComparableImplementedButEqualsNotOverridden
Comparator class not declared Serializable ComparatorNotSerializable
Comparison of 'short' and 'char' values ComparisonOfShortAndChar
Comparison to Double.NaN or Float.NaN ComparisonToNaN
Concatenation with empty string ConcatenationWithEmptyString
Conditional expression (?:) ConditionalExpression
Conditional expression with identical branches ConditionalExpressionWithIdenticalBranches
Conditional expression with negated condition ConditionalExpressionWithNegatedCondition
Conditional that can be simplified to && or || SimplifiableConditionalExpression
Confusing 'else' branch ConfusingElseBranch
Confusing 'main()' method ConfusingMainMethod
Confusing 'null' argument to var-arg method NullArgumentToVariableArgMethod
Confusing floating-point literal ConfusingFloatingPointLiteral
Confusing octal escape sequence ConfusingOctalEscapeSequence
Confusing primitive array argument to var-arg method PrimitiveArrayArgumentToVariableArgMethod
Connection opened but not safely closed ConnectionOpenedButNotSafelyClosed
Constant StringBuffer may be String StringBufferReplaceableByString
Constant call to java.lang.Math or StrictMath ConstantMathCall
Constant conditional expression ConstantConditionalExpression
Constant declared in abstract class ConstantDeclaredInAbstractClass
Constant declared in interface ConstantDeclaredInInterface
Constant if statement ConstantIfStatement
Constant naming convention ConstantNamingConvention
Constant on left side of comparison ConstantOnLeftSideOfComparison
Constant on right side of comparison ConstantOnRightSideOfComparison
Constructor not 'protected' in 'abstract' class ConstructorNotProtectedInAbstractClass
Constructor with too many parameters ConstructorWithTooManyParameters
Control flow statement without braces ControlFlowStatementWithoutBraces
Covariant 'compareTo()' CovariantCompareTo
Covariant 'equals()' CovariantEquals
Custom ClassLoader CustomClassloader
Custom SecurityManager CustomSecurityManager
Deserializable class in secure context DeserializableClassInSecureContext
Design for extension DesignForExtension
Division by zero divzero
Double negation DoubleNegation
Double-checked locking DoubleCheckedLocking
Duplicate condition in 'if' statement DuplicateCondition
Duplicate condition on '&&' or '||' DuplicateBooleanBranch
Empty 'catch' block EmptyCatchBlock
Empty 'finally' block EmptyFinallyBlock
Empty 'synchronized' statement EmptySynchronizedStatement
Empty 'try' block EmptyTryBlock
Empty class EmptyClass
Empty class initializer EmptyClassInitializer
Enum 'switch' statement that misses case EnumSwitchStatementWhichMissesCases
Enumerated class EnumClass
Enumerated class naming convention EnumeratedClassNamingConvention
Enumerated constant naming convention EnumeratedConstantNamingConvention
Enumeration can be iteration EnumerationCanBeIteration
Exception class name does not end with 'Exception' ExceptionClassNameDoesntEndWithException
Extended 'for' statement ForeachStatement
Externalizable class with 'readObject()' or 'writeObject()' ExternalizableClassWithSerializationMethods
Fallthrough in 'switch' statement fallthrough
Feature envy FeatureEnvy
Field accessed in both synchronized and unsynchronized contexts FieldAccessedSynchronizedAndUnsynchronized
Field has setter but no getter FieldHasSetterButNoGetter
Field may be 'static' FieldMayBeStatic
Field name hides field in superclass FieldNameHidesFieldInSuperclass
Field repeatedly accessed in method FieldRepeatedlyAccessedInMethod
Floating point equality comparison FloatingPointEquality
Hardcoded file separator HardcodedFileSeparator
Hardcoded line separator HardcodedLineSeparator
Hibernate resource opened but not safely closed HibernateResourceOpenedButNotSafelyClosed
I/O resource opened but not safely closed IOResourceOpenedButNotSafelyClosed
If statement may be replaced by && or || expression SimplifiableIfStatement
Implicit call to 'super()' ImplicitCallToSuper
Implicit call to array '.toString()' ImplicitArrayToString
Implicit numeric conversion ImplicitNumericConversion
Import from same package SamePackageImport
Incompatible bitwise mask operation IncompatibleBitwiseMaskOperation
Infinite loop statement InfiniteLoopStatement
Infinite recursion InfiniteRecursion
Inner class field hides outer class field InnerClassFieldHidesOuterClassField
Inner class may be 'static' InnerClassMayBeStatic
Inner class of interface InnerClassOfInterface
Inner class too deeply nested InnerClassTooDeeplyNested
Insecure random number generation UnsecureRandomNumberGeneration
Inspection suppression annotation SuppressionAnnotation
Instance method naming convention InstanceMethodNamingConvention
Instance variable may not be initialized InstanceVariableMayNotBeInitialized
Instance variable may not be initialized by 'readObject()' InstanceVariableMayNotBeInitializedByReadObject
Instance variable naming convention InstanceVariableNamingConvention
Instance variable of concrete class InstanceVariableOfConcreteClass
Instance variable used before initialized InstanceVariableUsedBeforeInitialized
Instantiating a SimpleDateFormat without a Locale SimpleDateFormatWithoutLocale
Instantiating a Thread with default 'run()' method InstantiatingAThreadWithDefaultRunMethod
Instantiating object to get Class object InstantiatingObjectToGetClassObject
Instantiation of utility class InstantiationOfUtilityClass
Integer division in floating point context IntegerDivisionInFloatingPointContext
Integer multiplication or shift implicitly cast to long IntegerMultiplicationImplicitCastToLong
Interface naming convention InterfaceNamingConvention
Interface which has no concrete subclass InterfaceNeverImplemented
Interface which has only one direct inheritor InterfaceWithOnlyOneDirectInheritor
JDBC resource opened but not safely closed JDBCResourceOpenedButNotSafelyClosed
JNDI resource opened but not safely closed JNDIResourceOpenedButNotSafelyClosed
JUnit TestCase in product source JUnitTestCaseInProductSource
JUnit TestCase with non-trivial constructors JUnitTestCaseWithNonTrivialConstructors
JUnit abstract test class naming convention JUnitAbstractTestClassNamingConvention
JUnit test case with no tests JUnitTestCaseWithNoTests
JUnit test class naming convention JUnitTestClassNamingConvention
JUnit test method in product source JUnitTestMethodInProductSource
JUnit test method without any assertions JUnitTestMethodWithNoAssertions
Labeled statement LabeledStatement
Large array allocation with no OutOfMemoryError check CheckForOutOfMemoryOnLargeArrayAllocation
Limited-scope inner class LimitedScopeInnerClass
Local variable hides member variable LocalVariableHidesMemberVariable
Local variable naming convention LocalVariableNamingConvention
Local variable of concrete class LocalVariableOfConcreteClass
Local variable used and declared in different 'switch' branches LocalVariableUsedAndDeclaredInDifferentSwitchBranches
Lock acquired but not safely unlocked LockAcquiredButNotSafelyReleased
Long literal ending with 'l' instead of 'L' LongLiteralEndingWithLowercaseL
Loop statement that does not loop LoopStatementThatDoesntLoop
Loop variable not updated inside loop LoopConditionNotUpdatedInsideLoop
Loop with implicit termination condition LoopWithImplicitTerminationCondition
Malformed @Before or @After method BeforeOrAfterWithIncorrectSignature
Malformed @BeforeClass or @AfterClass method BeforeOrAfterWithIncorrectSignature
Malformed XPath expression MalformedXPath
Malformed format string MalformedFormatString
Malformed regular expression MalformedRegex
Manual array copy ManualArrayCopy
Manual array to collection copy ManualArrayToCollectionCopy
Map or Set may contain java.net.URL objects CollectionContainsUrl
Map replaceable by EnumMap MapReplaceableByEnumMap
Marker interface MarkerInterface
Message missing on JUnit assertion MessageMissingOnJUnitAssertion
Method call in loop condition MethodCallInLoopCondition
Method call violates Law of Demeter LawOfDemeter
Method is identical to its super method RedundantMethodOverride
Method may be 'static' MethodMayBeStatic
Method name same as class name MethodNameSameAsClassName
Method name same as parent class name MethodNameSameAsParentName
Method names differing only by case MethodNamesDifferingOnlyByCase
Method overloads method of superclass MethodOverloadsMethodOfSuperclass
Method overrides package local method of superclass located in other package MethodOverridesPrivateMethodOfSuperclass
Method overrides private method of superclass MethodOverridesPrivateMethodOfSuperclass
Method overrides static method of superclass MethodOverridesStaticMethodOfSuperclass
Method parameter naming convention MethodParameterNamingConvention
Method parameter of concrete class MethodParameterOfConcreteClass
Method return of concrete class MethodReturnOfConcreteClass
Method with more than three negations MethodWithMoreThanThreeNegations
Method with multiple loops MethodWithMultipleLoops
Method with multiple return points. MethodWithMultipleReturnPoints
Method with synchronized block could be synchronized method MethodMayBeSynchronized
Method with too many exceptions declared MethodWithTooExceptionsDeclared
Method with too many parameters MethodWithTooManyParameters
Mismatched query and update of collection MismatchedQueryAndUpdateOfCollection
Mismatched read and write of array MismatchedReadAndWriteOfArray
Misordered 'assertEquals()' parameters MisorderedAssertEqualsParameters
Missing @Deprecated annotation MissingDeprecatedAnnotation
Missing @Override annotation override
Missorted modifers MissortedModifiers
Multiple top level classes in single file MultipleTopLevelClassesInFile
Multiple variables in one declaration MultipleVariablesInDeclaration
Multiply or divide by power of two MultiplyOrDivideByPowerOfTwo
Native method NativeMethod
Nested 'switch' statement NestedSwitchStatement
Nested 'synchronized' statement NestedSynchronizedStatement
Nested 'try' statement NestedTryStatement
Nested assignment NestedAssignment
Nested conditional expression NestedConditionalExpression
Nested method call NestedMethodCall
No-op method in abstract class NoopMethodInAbstractClass
Non-boolean method name must not start with question word NonBooleanMethodNameMayNotStartWithQuestion
Non-constant String should be StringBuffer NonConstantStringShouldBeStringBuffer
Non-constant field with upper-case name NonConstantFieldWithUpperCaseName
Non-constant logger NonConstantLogger
Non-exception class name ends with 'Exception' NonExceptionNameEndsWithException
Non-final 'clone()' in secure context NonFinalClone
Non-final field of exception class NonFinalFieldOfException
Non-final field referenced in 'compareTo()' CompareToUsesNonFinalVariable
Non-final field referenced in 'equals()' NonFinalFieldReferenceInEquals
Non-final field referenced in 'hashCode()' NonFinalFieldReferencedInHashCode
Non-final static variable is used during class initialization NonFinalStaticVariableUsedInClassInitialization
Non-private field accessed in synchronized context NonPrivateFieldAccessedInSynchronizedContext
Non-reproducible call to java.lang.Math NonReproducibleMathCall
Non-serializable class with 'readObject()' or 'writeObject()' NonSerializableClassWithSerializationMethods
Non-serializable class with 'serialVersionUID' NonSerializableClassWithSerialVersionUID
Non-serializable field in a Serializable class NonSerializableFieldInSerializableClass
Non-serializable object bound to HttpSession NonSerializableObjectBoundToHttpSession
Non-serializable object passed to ObjectOutputStream NonSerializableObjectPassedToObjectStream
Non-short-circuit boolean expression NonShortCircuitBooleanExpression
Non-static initializer NonStaticInitializer
Non-static inner class in secure context NonStaticInnerClassInSecureContext
Non-synchronized method overrides synchronized method NonSynchronizedMethodOverridesSynchronizedMethod
Number comparison using '==', instead of 'equals()' NumberEquality
Number constructor call with primitive argument CachedNumberConstructorCall
Numeric cast that loses precision NumericCastThatLosesPrecision
Object allocation in loop ObjectAllocationInLoop
Object comparison using ==, instead of 'equals()' ObjectEquality
Object.equals(null) ObjectEqualsNull
Octal and decimal integers in same array OctalAndDecimalIntegersInSameArray
Octal integer OctalInteger
Overloaded methods with same number of parameters OverloadedMethodsWithSameNumberOfParameters
Overloaded variable argument method OverloadedVarargsMethod
Overly broad 'catch' block OverlyBroadCatchBlock
Overly complex anonymous inner class OverlyComplexAnonymousInnerClass
Overly complex arithmetic expression OverlyComplexArithmeticExpression
Overly complex boolean expression OverlyComplexBooleanExpression
Overly complex class OverlyComplexClass
Overly complex method OverlyComplexMethod
Overly coupled class OverlyCoupledClass
Overly coupled method OverlyCoupledMethod
Overly large initializer for array of primitive type OverlyLargePrimitiveArrayInitializer
Overly long method OverlyLongMethod
Overly nested method OverlyNestedMethod
Overly-strong type cast OverlyStrongTypeCast
Overridable method call during object construction OverridableMethodCallDuringObjectConstruction
Overridden method call during object construction OverriddenMethodCallDuringObjectConstruction
Package-visible field PackageVisibleField
Package-visible inner class PackageVisibleInnerClass
Parameter hides member variable ParameterHidesMemberVariable
Parameter name differs from parameter in overridden method ParameterNameDiffersFromOverriddenParameter
Pointless 'indexOf()' comparison PointlessIndexOfComparison
Pointless arithmetic expression PointlessArithmeticExpression
Pointless bitwise expression PointlessBitwiseExpression
Pointless boolean expression PointlessBooleanExpression
Private member access between outer and inner classes PrivateMemberAccessBetweenOuterAndInnerClass
Private method only used from inner class MethodOnlyUsedFromInnerClass
Prohibited exception caught ProhibitedExceptionCaught
Prohibited exception declared ProhibitedExceptionDeclared
Prohibited exception thrown ProhibitedExceptionThrown
Protected field ProtectedField
Protected inner class ProtectedInnerClass
Public field PublicField
Public inner class PublicInnerClass
Public method not exposed in interface PublicMethodNotExposedInInterface
Public method without logging PublicMethodWithoutLogging
Public static array field PublicStaticArrayField
Public static collection field PublicStaticCollectionField
Questionable name QuestionableName
Raw use of parameterized class RawUseOfParameterizedType
RecordStore opened but not safely closed RecordStoreOpenedButNotSafelyClosed
Redundant '.substring(0)' SubstringZero
Redundant 'String.toString()' RedundantStringToString
Redundant 'if' statement RedundantIfStatement
Redundant String constructor call RedundantStringConstructorCall
Redundant conditional expression RedundantConditionalExpression
Redundant field initialization RedundantFieldInitialization
Redundant import RedundantImport
Redundant interface declaration RedundantInterfaceDeclaration
Redundant local variable UnnecessaryLocalVariable
Redundant no-arg constructor RedundantNoArgConstructor
Reflective access to a source-only annotation ReflectionForUnavailableAnnotation
Refused bequest RefusedBequest
Result of method call ignored ResultOfMethodCallIgnored
Result of object allocation ignored ResultOfObjectAllocationIgnored
Return of 'null' ReturnOfNull
Return of 'this' ReturnOfThis
Return of Collection or array field ReturnOfCollectionOrArrayField
Return of Date or Calendar field ReturnOfDateField
Reuse of local variable ReuseOfLocalVariable
Scope of variable is too broad TooBroadScope
Serializable class in secure context SerializableClassInSecureContext
Serializable class with unconstructable ancestor SerializableClassWithUnconstructableAncestor
Serializable class without 'readObject()' and 'writeObject()' SerializableHasSerializationMethods
Serializable class without 'serialVersionUID' serial
Serializable non-static inner class with non-Serializable outer class SerializableInnerClassWithNonSerializableOuterClass
Serializable non-static inner class without 'serialVersionUID' SerializableNonStaticInnerClassWithoutSerialVersionUID
Set replaceable by EnumSet SetReplaceableByEnumSet
Shift operation by inappropriate constant ShiftOutOfRange
Simplifiable JUnit assertion SimplifiableJUnitAssertion
Single character 'startsWith()' or 'endsWith()' SingleCharacterStartsWith
Single character string concatenation SingleCharacterStringConcatenation
Single character string parameter in 'String.indexOf()' call SingleCharacterStringConcatenation
Single class import SingleClassImport
Singleton Singleton
Socket opened but not safely closed SocketOpenedButNotSafelyClosed
Standard variable names StandardVariableNames
Statement with empty body StatementWithEmptyBody
Static collection StaticCollection
Static field referenced via subclass StaticFieldReferencedViaSubclass
Static import StaticImport
Static inheritance StaticInheritance
Static method naming convention StaticMethodNamingConvention
Static method only used from one other class StaticMethodOnlyUsedInOneClass
Static method referenced via subclass StaticMethodReferencedViaSubclass
Static variable may not be initialized StaticVariableMayNotBeInitialized
Static variable naming convention StaticVariableNamingConvention
Static variable of concrete class StaticVariableOfConcreteClass
Static variable used before initialization StaticVariableUsedBeforeInitialization
String comparison using '==', instead of 'equals()' StringEquality
String concatenation StringConcatenation
String concatenation in loop StringContatenationInLoop
String concatenation inside 'StringBuffer.append()' StringConcatenationInsideStringBufferAppend
StringBuffer constructor call with 'char' argument NewStringBufferWithCharArgument
StringBuffer field StringBufferField
StringBuffer or StringBuilder without initial capacity StringBufferWithoutInitialCapacity
Subtraction in compareTo() SubtractionInCompareTo
Suspicious 'Collections.toArray()' call SuspiciousToArrayCall
Suspicious 'System.arraycopy()' call SuspiciousSystemArraycopy
Suspicious indentation after control statement without braces SuspiciousIndentAfterControlStatement
Suspicious test for oddness BadOddness
Synchronization on 'this' SynchronizeOnThis
Synchronization on a Lock object SynchroniziationOnLockObject
Synchronization on a non-final field SynchronizeOnNonFinalField
Synchronization on an object initialized with a literal SynchronizedOnLiteralObject
TODO comment TodoComment
Tail recursion TailRecursion
Test method with incorrect signature TestMethodWithIncorrectSignature
Text label in 'switch' statement TextLabelInSwitchStatement
Throwable instance not thrown ThrowableInstanceNeverThrown
Transient field in non-serializable class TransientFieldInNonSerializableClass
Transient field is not initialized on deserialization TransientFieldNotInitialized
Type may be weakened TypeMayBeWeakened
Type parameter explicitly extends 'java.lang.Object' TypeParameterExplicitlyExtendsObject
Type parameter extends final class TypeParameterExtendsFinalClass
Type parameter hides visible type TypeParameterHidesVisibleType
Type parameter naming convention TypeParameterNamingConvention
Unary plus UnaryPlus
Unchecked exception class UncheckedExceptionClass
Unconditional 'wait()' call UnconditionalWait
Unconstructable JUnit TestCase UnconstructableJUnitTestCase
Unnecessarily qualified static usage UnnecessarilyQualifiedStaticUsage
Unnecessary 'continue' statement UnnecessaryContinue
Unnecessary 'default' for enum switch statement UnnecessaryDefault
Unnecessary 'final' for local variable UnnecessaryFinalOnLocalVariable
Unnecessary 'final' for method parameter UnnecessaryFinalForMethodParameter
Unnecessary 'return' statement UnnecessaryReturnStatement
Unnecessary 'this' qualifier UnnecessaryThis
Unnecessary boxing UnnecessaryBoxing
Unnecessary call to 'super()' UnnecessaryCallToSuper
Unnecessary code block UnnecessaryCodeBlock
Unnecessary enum modifier UnnecessaryEnumModifier
Unnecessary fully qualified name UnnecessaryFullyQualifiedName
Unnecessary interface modifier UnnecessaryInterfaceModifier
Unnecessary label on 'break' statement UnnecessaryLabelOnBreakStatement
Unnecessary label on 'continue' statement UnnecessaryLabelOnContinueStatement
Unnecessary parentheses UnnecessaryParentheses
Unnecessary qualifier for 'this' UnnecessaryQualifierForThis
Unnecessary semicolon UnnecessarySemicolon
Unnecessary temporary object in conversion from String UnnecessaryTemporaryOnConversionFromString
Unnecessary temporary object in conversion to String UnnecessaryTemporaryOnConversionToString
Unnecessary unary minus UnnecessaryUnaryMinus
Unnecessary unboxing UnnecessaryUnboxing
Unpredictable BigDecimal constructor call UnpredictableBigDecimalConstructorCall
Unqualified instance field access UnqualifiedFieldAccess
Unqualified static usage UnqualifiedStaticUsage
Unsafe lazy initialization of static field NonThreadSafeLazyInitialization
Unused 'catch' parameter UnusedCatchParameter
Unused import UnusedImport
Unused label UnusedLabel
Use of '$' in identifier DollarSignInName
Use of 'assert' as identifier AssertAsIdentifier
Use of 'enum' as identifier EnumAsIdentifier
Use of AWT peer class UseOfAWTPeerClass
Use of DriverManager to get JDBC connection CallToDriverManagerGetConnection
Use of Properties object as a Hashtable UseOfPropertiesAsHashtable
Use of StringTokenizer UseOfStringTokenizer
Use of System.out or System.err UseOfSystemOutOrSystemErr
Use of archaic system property accessors UseOfArchaicSystemPropertyAccessors
Use of concrete JDBC driver class UseOfJDBCDriverClass
Use of index 0 in JDBC ResultSet UseOfIndexZeroInJDBCResultSet
Use of java.lang.ProcessBuilder class UseOfProcessBuilder
Use of java.lang.reflect JavaLangReflect
Use of obsolete collection type UseOfObsoleteCollectionType
Use of sun.* classes UseOfSunClasses
Using 'Random.nextDouble()' to get random integer UsingRandomNextDoubleForRandomInteger
Utility class UtilityClass
Utility class with public constructor UtilityClassWithPublicConstructor
Utility class without private constructor UtilityClassWithoutPrivateConstructor
Value of ++ or -- used ValueOfIncrementOrDecrementUsed
Variable argument method VariableArgumentMethod
Variables of different types in one declaration VariablesOfDifferentTypesInDeclaration
Volatile array field VolatileArrayField
Volatile long or double field VolatileLongOrDoubleField
While loop spins on field WhileLoopSpinsOnField
Zero-length array allocation ZeroLengthArrayAllocation
expression.equals("literal") rather than "literal".equals(expression) LiteralAsArgToStringEquals
java.lang import JavaLangImport
java.lang.Error not rethrown ErrorNotRethrown
java.lang.ThreadDeath not rethrown ThreadDeathNotRethrown
Redundant array creation for calling varargs method RedundantArrayCreation
Actual value of parameter 'x' is always 'y' SameParameterValue
But maybe it's easier to let IDEA do the work for you;