Static analysis and remediation

Remediations for issues identified by SAST tools.

Composite Recipes

Recipes that include further recipes, often including the individual recipes below.

• Code cleanup

• Common static analysis issues

• Replace org.apache.commons.lang3.Validate#notNull with Objects#requireNonNull

• Replace org.apache.commons.lang3.Validate#notNull with Objects#requireNonNull

• Simplify ternary expressions

Recipes

• Add missing @Override to overriding and implementing methods

• Add serialVersionUID to a Serializable class when missing

• Atomic Boolean, Integer, and Long equality checks compare their values

• Avoid boxed boolean expressions

• BigDecimal rounding constants to RoundingMode enums

• Boolean checks should not be inverted

• CaseInsensitive comparisons do not alter case

• Catch clause should do more than just rethrow

• Chain StringBuilder.append() calls

• Change StringBuilder and StringBuffer character constructor argument to String

• Changes code to use Java 17's instanceof pattern matching

• Combine semantically equal catch blocks

• Control flow statement indentation

• Covariant equals

• Default comes last

• Don't use final on local variables

• Enum values should be compared with "=="

• Equals avoids null

• Explicit initialization

• Externalizable classes have no-arguments constructor

• Fall through

• Finalize classes with private constructors

• Finalize local variables

• Finalize method arguments

• Finalize private fields

• Fix String#format and String#formatted expressions

• Fix missing braces

• Hidden field

• Hide utility class constructor

• Inline variable

• Java API best practices

• Jump statements should not be redundant

• Method name casing

• Modifier order

• Nested enums are not static

• No C-style array declarations

• No double brace initialization

• No multiple variable declarations

• No primitive wrappers for #toString() or #compareTo(..)

• Operator wrapping

• Prefer while over for loops

• Properly use declaration-site type variance

• Properly use declaration-site type variance for well-known types

• Redundant file creation

• Reformat local variable names to camelCase

• Reformat private field names to camelCase

• Remove JavaDoc @param, @return, and @throws with no description

• Remove Nullable and CheckForNull annotations from primitives

• Remove Object.finalize() invocations

• Remove System.out#println statements

• Remove Unneeded Assertions

• Remove author tags from JavaDocs

• Remove catch for a checked exception if the try block does not throw that exception

• Remove empty blocks

• Remove extra semicolons

• Remove finalize() method

• Remove garbage collection invocations

• Remove redundant casts

• Remove toString() calls on arrays

• Remove unnecessary parentheses

• Remove unneeded block

• Remove unused local variables

• Remove unused private fields

• Remove unused private methods

• Removes from code Java 14's instanceof pattern matching

• Rename caught exceptions in empty catch blocks to ignored

• Rename methods named hashcode, equal, or tostring

• Rename packages to lowercase

• Replace Optional#isPresent() with Optional#ifPresent()

• Replace Stream.toList() with Stream.collect(Collectors.toList())

• Replace StringBuilder.append() with String

• Replace booleanExpression ? false : true with !booleanExpression

• Replace booleanExpression ? true : false with booleanExpression

• Replace calls to Thread.run() with Thread.start()

• Replace deprecated Runtime#exec() methods

• Replace duplicate String literals

• Replace invocations of Collections#sort(List, Comparator) with List#sort(Comparator)

• Replace java.util.Set#removeAll(java.util.Collection) with java.util.Collection#forEach(Set::remove)

• Replace java.util.Stack with java.util.Deque

• Replace org.apache.commons.lang3.Validate#notNull with Objects#requireNonNull

• Replace redundant String format invocations that are wrapped with PrintStream operations

• Replace referential equality operators with Object equals method invocations when the operands both override Object.equals(Object obj)

• Replace text block with regular string

• Replaces Object.notify() with Object.notifyAll()

• Set charset encoding explicitly when calling String#getBytes

• Simplify boolean expression

• Simplify boolean return

• Simplify compound statement

• Simplify consecutive assignments

• Simplify constant if branch execution

• Simplify java.time.Duration units

• Simplify lambda blocks to expressions

• Sorted set stream should be collected to LinkedHashSet

• Static methods not final

• Ternary operators should not be nested

• Typecast parenthesis padding

• Unnecessary String#toString()

• Unnecessary String#valueOf(..)

• Unnecessary close in try-with-resources

• Unnecessary explicit type arguments

• Unnecessary throws

• Unwrap @Repeatable annotations

• Upper case literal suffixes

• Use Collection interfaces

• Use Collection#isEmpty() instead of comparing size()

• Use Collections#emptyList(), emptyMap(), and emptySet()

• Use Empty Array for Collection.toArray()

• Use Map#containsKey

• Use StandardCharset constants

• Use String.contentEquals(CharSequence) instead of String.equals(CharSequence.toString())

• Use String.equals() on String literals

• Use String::replace() when fist parameter is not a real regular expression

• Use System.lineSeparator()

• Use comparison rather than equality checks in for conditions

• Use diamond operator

• Use explicit types on lambda arguments

• Use indexOf(String, int)

• Use lambda expressions instead of anonymous classes

• Use method references in lambda

• Use primitive wrapper valueOf method

• Use the builder pattern where possible

• Week Year (YYYY) should not be used for date formatting

• Write octal values as decimal

• finalize() calls super

• for loop counters incremented in update

• for loop counters should use postfix operators

• hashCode() should not be called on array instances

• indexOf should not compare greater than zero

• indexOf() replaceable by contains()

• new BigDecimal(double) should not be used

• switch statements should have at least 3 case clauses