Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
SuppressWarnings with IntelliJ Idea

@SuppressWarnings - IntelliJ modes

Information

This list may grow each year with either new versions or patches. Enjoy!

Usage

Following is an example related to the usage of the various ignore capabilities.

	@SuppressWarnings("MagicCharacter")
	@SuppressWarnings("AssertStatement")
	@SuppressWarnings("AwaitWithoutCorrespondingSignal")

Types

  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 
@crtlib
Copy link

crtlib commented Mar 10, 2018

Call to 'asList' with only one argument ArraysAsListWithZeroOrOneArgument

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment