Inspectopedia Help

Probable bugs

'Comparable' implemented but 'equals()' not overridden  

Reports classes that implement java.lang.Comparable but do not override equals().

'Iterator.hasNext()' which calls 'next()'  

Reports implementations of Iterator.hasNext() or ListIterator.hasPrevious() that call or ListIterator.previous() on the iterator instance.

'' which can't throw 'NoSuchElementException'  

Reports implementations of that cannot throw java.util.NoSuchElementException.

'Math.random()' cast to 'int'  

Reports calls to Math.random() which are immediately cast to int.

'ScheduledThreadPoolExecutor' with zero core threads  

Reports any java.util.concurrent.ScheduledThreadPoolExecutor instances in which corePoolSize is set to zero via the setCorePoolSize method or the object constructor.

'String.equals()' called with 'CharSequence' argument  

Reports calls to String.equals() with a CharSequence as the argument.

'Throwable' not thrown  

Reports instantiations of Throwable or its subclasses, where the created Throwable is never actually thrown.

'assert' statement with side effects  

Reports assert statements that cause side effects.

'equal()' instead of 'equals()'  

Reports declarations of equal() with a single parameter.

'equals()' and 'hashCode()' not paired  

Reports classes that override the equals() method but do not override the hashCode() method or vice versa, which can potentially lead to problems when the class is added to a Collection or a HashMap.

'equals()' between objects of inconvertible types  

Reports calls to equals() where the target and argument are of incompatible types.

'equals()' called on array  

Reports equals() calls that compare two arrays.

'equals()' called on classes which don't override it  

Reports equals() calls on StringBuilder, StringBuffer and instances of java.util.concurrent.atomic package.

'equals()' called on itself  

Reports calls to equals(), compareTo() or similar, that compare an object for equality with itself.

'equals()' method which does not check class of parameter  

Reports equals() methods that do not check the type of their parameter.

'hashCode()' called on array  

Reports incorrect hash code calculation for arrays.

'instanceof' with incompatible type  

Reports instanceof expressions where the expression that is checked has a class/interface type that neither extends/implements the class/interface type on the right-side of the instanceof expression, nor has subclasses that do.

Array comparison using '==', instead of 'Arrays.equals()'  

Reports operators == and != used to test for array equality.

Call math rounding with 'int' argument  

Reports calls to round(), ceil(), floor(), rint() methods for Math and StrictMath with int as the argument.

Call methods with unsupported 'java.time.temporal.ChronoUnit' and 'java.time.temporal.ChronoField'  

Reports java.time method calls (get(), getLong(), with(), plus(), minus()) with unsupported java.time.temporal.ChronoField or java.time.temporal.ChronoUnit enum constants as arguments.

Call to 'toString()' on array  

Reports arrays used in String concatenations or passed as parameters to methods, such as System.out.println().

Call to default 'toString()'  

Reports calls to toString() that use the default implementation from java.lang.Object.

Cast conflicts with 'instanceof'  

Reports type cast expressions that are preceded by an instanceof check for a different type.

Cast to incompatible type  

Reports type cast expressions where the casted expression has a class/interface type that neither extends/implements the cast class/interface type, nor has subclasses that do.

Cleaner captures object reference  

Reports Runnable passed to a Cleaner.register() capturing reference being registered.

Collection added to itself  

Reports cases where the argument of a method call on a java.util.Collection or java.util.Map is the collection or map itself.

Confusing 'main()' method  

Reports methods that are named "main", but do not have the public static void main(String[]) signature in Java up to 21.

Confusing argument to varargs method  

Reports calls to variable arity methods that have a single argument in the vararg parameter position, which is either a null or an array of a subtype of the vararg parameter.

Confusing primitive array argument to varargs method  

Reports any calls to a variable arity method where the call has a primitive array in the variable arity parameter position (for example, System.out.printf("%s", new int[]{1, 2, 3})).

Constant condition in 'assert' statement  

Reports assert statement conditions that are constants.

Constant values  

Reports expressions and conditions that always produce the same result, like true, false, null, or zero.

Contract issues  

Reports issues in method @Contract annotations.

Copy constructor misses field  

Reports copy constructors that don't copy all the fields of the class.

Covariant 'equals()'  

Reports equals() methods taking an argument type other than java.lang.Object if the containing class does not have other overloads of equals() that take java.lang.Object as its argument type.

Duplicated delimiters in 'StringTokenizer'  

Reports StringTokenizer() constructor calls or nextToken() method calls that contain duplicate characters in the delimiter argument.

Inconsistent whitespace indentation in text block  

Reports text blocks that are indented using both spaces and tabs.

Incorrect 'DateTimeFormat' pattern  

Reports incorrect date time format patterns.

Incorrect 'MessageFormat' pattern  

Reports incorrect message format patterns or incorrect indexes of placeholders The following errors are reported: Unparsed or negative index Unclosed brace Unpaired quote.

Infinite recursion  

Reports methods that call themselves infinitely unless an exception is thrown.

Inner class referenced via subclass  

Reports accesses of inner and nested classes where the call is qualified by a subclass of the declaring class, rather than the declaring class itself.

Instantiation of utility class  

Reports instantiation of utility classes using the new keyword.

Invalid method reference used for 'Comparator'  

Reports method references mapped to the Comparator interface that don't fulfill its contract.

Iterable is used as vararg  

Reports suspicious usages of Collection or Iterable in vararg method calls.

Loop executes zero or billions of times  

Reports loops that cannot be completed without an index overflow or loops that don't loop at all.

Magic constant  

Reports expressions that can be replaced with "magic" constants.

Malformed format string  

Reports format strings that don't comply with the standard Java syntax.

Meaningless record annotation  

Reports annotations used on record components that have no effect.

Mismatched case in 'String' operation  

Reports String method calls that always return the same value (-1 or false) because a lowercase character is searched in an uppercase-only string or vice versa.

Mismatched query and update of 'StringBuilder'  

Reports StringBuilder, StringBuffer or StringJoiner objects whose contents are read but not written to, or written to but not read.

Mismatched query and update of collection  

Reports collections whose contents are either queried and not updated, or updated and not queried.

Mismatched read and write of array  

Reports arrays whose contents are read but not updated, or updated but not read.

New object is compared using '=='  

Reports code that applies == or != to a newly allocated object instead of calling equals().

Non-final field referenced in 'compareTo()'  

Reports access to a non-final field inside a compareTo() implementation.

Non-final field referenced in 'equals()'  

Reports implementations of equals() that access non-final variables.

Non-final field referenced in 'hashCode()'  

Reports implementations of hashCode() that access non-final variables.

Non-short-circuit boolean expression  

Reports usages of the non-short-circuit forms of boolean 'and' and 'or' (&, |, &= and |=).

Non-short-circuit operation consumes infinite stream  

Reports non-short-circuit operations consuming an infinite stream.

Nullability and data flow problems  

Reports code constructs that always violate nullability contracts, may throw exceptions, or are just redundant, based on data flow analysis.

Number comparison using '==', instead of 'equals()'  

Reports code that uses == or != instead of equals() to test for Number equality.

Object comparison using '==', instead of 'equals()'  

Reports code that uses == or != rather than equals() to test for object equality.

Optional.get() is called without isPresent() check  

Reports calls to get() on an Optional without checking that it has a value.

Overwritten Map, Set, or array element  

Reports code that overwrites a Map key, a Set element, or an array element in a sequence of add/put calls or using a Java 9 factory method like Set.of (which will result in runtime exception).

Redundant operation on empty container  

Reports redundant operations on empty collections, maps or arrays.

Reference checked for 'null' is not used inside 'if'  

Reports references to variables that are checked for nullability in the condition of an if statement or conditional expression but not used inside that if statement.

Reflective access to a source-only annotation  

Reports attempts to reflectively check for the presence of a non-runtime annotation.

Result of method call ignored  

Reports method calls whose result is ignored.

Result of object allocation ignored  

Reports object allocations where the allocated object is ignored and neither assigned to a variable nor used in another way.

Sorted collection with non-comparable elements  

Reports construction of sorted collections, for example TreeSet, that rely on natural ordering, whose element type doesn't implement the Comparable interface.

Statement with empty body  

Reports if, while, do, for, and switch statements with empty bodies.

Static field referenced via subclass  

Reports accesses to static fields where the call is qualified by a subclass of the declaring class, rather than by the declaring class itself.

Static method referenced via subclass  

Reports static method calls where the call is qualified by a subclass of the declaring class, rather than by the declaring class itself.

String comparison using '==', instead of 'equals()'  

Reports code that uses of == or != to compare strings.

String concatenation as argument to 'MessageFormat.format()' call  

Reports non-constant string concatenations used as an argument to a call to MessageFormat.format().

String concatenation as argument to 'format()' call  

Reports non-constant string concatenations used as a format string argument.

StringBuilder constructor call with 'char' argument  

Reports calls to StringBuffer and StringBuilder constructors with char as the argument.

Subtraction in 'compareTo()'  

Reports subtraction in compareTo() methods and methods implementing

Suspicious 'Arrays' method call  

Reports calls to non-generic-array manipulation methods like Arrays.fill() with mismatched argument types.

Suspicious 'Class.getClass()' call  

Reports getClass() methods that are called on a java.lang.Class instance.

Suspicious 'Collection.toArray()' call  

Reports suspicious calls to Collection.toArray().

Suspicious '' implementation  

Reports problems in and Comparable.compareTo() implementations.

Suspicious 'InvocationHandler' implementation  

Reports implementations of InvocationHandler that do not proxy standard Object methods like hashCode(), equals(), and toString().

Suspicious 'List.remove()' in loop  

Reports list.remove(index) calls inside an ascending counted loop.

Suspicious 'System.arraycopy()' call  

Reports suspicious calls to System.arraycopy().

Suspicious array cast  

Reports suspicious array casts.

Suspicious byte value returned from ''  

Reports expressions of byte type returned from a method implementing the method.

Suspicious collection method call  

Reports method calls on parameterized collections, where the actual argument type does not correspond to the collection's elements type.

Suspicious date format pattern  

Reports date format patterns that are likely used by mistake.

Suspicious indentation after control statement without braces  

Reports suspicious indentation of statements after a control statement without braces.

Suspicious integer division assignment  

Reports assignments whose right side is a division that shouldn't be truncated to integer.

Suspicious regex expression argument  

Reports calls to String.replaceAll() or String.split() where the first argument is a single regex meta character argument.

Suspicious ternary operator in varargs method call  

Reports vararg method calls that use a ternary operator with mixed array and non-array branches.

Suspicious usage of compare method  

Reports comparisons of the result of or Comparable.compareTo() calls with non-zero constants.

Suspicious variable/parameter name combination  

Reports assignments and function calls in which the name of the target variable or the function parameter does not match the name of the value assigned to it.

Text label in 'switch' statement  

Reports labeled statements inside of switch statements.

Unreachable code  

Reports the code which is never reached according to data flow analysis.

Unsafe call to 'Class.newInstance()'  

Reports calls to java.lang.Class.newInstance().

Unused assignment  

Reports assignment values that are not used after assignment.

Use of 'Properties' object as a 'Hashtable'  

Reports calls to the following methods on java.util.Properties objects: put() putIfAbsent() putAll() get() For historical reasons, java.util.Properties inherits from java.util.Hashtable, but using these methods is discouraged to prevent pollution of properties with values of types other than String.

Use of Optional.ofNullable with null or not-null argument  

Reports uses of Optional.ofNullable() where always null or always not-null argument is passed.

Use of index 0 in JDBC ResultSet  

Reports attempts to access column 0 of java.sql.ResultSet or java.sql.PreparedStatement.

Use of shallow or 'Objects' methods with arrays  

Reports expressions that seem to use an inappropriate method for determining array equality or calculating their hashcode.

Whitespace may be missing in string concatenation  

Reports string concatenations with missing whitespaces, that is where the left-hand side ends with a Unicode letter or digit and the right-hand side starts with a Unicode letter or digit.

Write-only object  

Reports objects that are modified but never queried.

Wrong package statement  

Detects package statements that do not correspond to the project directory structure.

Nullability problems  

Sub-group of 4 inspections that provide checks for Nullability problems

Last modified: 18 June 2024