This is a list of all the rules that are currently implemented in jSparrow.
Rule, Java 1.1, Formatting, Readability, Java 1.2, Conventions, Free, Java 5, Loop, Old Language Constructs, Coding Conventions, Java 10, Java 6, String Manipulation, Performance, Java 7, Java 8, Lambda, Java 1.4, Old language construct, Logging, Coding conventions
Free rules in jSparrow Starter
The following rules are included in jSparrow Starter. See the documentation at: Registration for 15 free rules.
Replaces occurrences of `equals()` on Enum constants with an identity comparison (`==`). In the case the equals relation is wrapped with an boolean negation the result will be an not equals (`!=`).
Checks if parenthesis are used to encapsulate control statements and adds them if they aren't present.
This rule simplifies expression lambdas by using method reference. The rule can only be applied if the parameters of the lambda expression and the method match.
While-loops over Iterators which could be expressed with a for-loop, are transformed to an equivalent for-loop.
Nested For-Loops or invocations of forEach commonly used to iterate over all elements of a collection of collections, can be avoided by using flatMap(). Using flatMap() makes code much more readable and can be combined with other stream functions.
All calls to a constructor of a primitive type will be replaced by the corresponding static valueOf() method. For example 'new Integer("1")' becomes 'Integer.valueOf("1")'.
Adds the modifiers static and final to SerialVersionUid long variables when they are absent.
Organize Imports according to the Eclipse's built in Organize Imports functionality.
Transforms enhanced for-loops which are only used for summing up the elements of a collection to a `Stream::sum` invocation.
This rule rearranges the body declarations of a class based on the Oracle Code Convention for File Organization.
When calling toString() on a boxed primitive no new instance of that primitive has to be created. This rule replaces occurrences of such code with a static method
Some java.util.Date constructors like new Date(int year, int month, int day), new Date(int year, int month, int date, int hrs, int min) and new Date(int year, int month, int date, int hrs, int min, int sec) are deprecated and the Calendar should be used instead. This rule searches for deprecated calendar instances, introduces calendar instances and sets the time corresponding to the parameters in the deprecated constructor, and replaces the latter with an invocation of Calendar.getTime().
Removes unnecessary explicit call to the default constructor of the super class.
Since Java 1.7 the Diamond Operator (`<>`) can be used to simplify instance creation where generics are involved.
This rule removes interfaces from class declaration, which are already implemented by a super class. These interfaces are inherited from the super class.
If the body of the lambda statement contains only a single expression, the braces are optional. It can be reduced to a lambda expression. This is comparable to if-statements or loops with a single expression inside their body, where braces are also optional.
This rule replaces enhanced for loops (for-each-loops) with an invocation of `java.util.stream.Stream::forEach`-method and passes the body of the for-loop as a lambda `Consumer` parameter.
Removes all invocations of toString() method used on a String element.
Removes the RuntimeExceptions, duplications and exceptions which are subtypes of already thrown exceptions on the method signatures.
Renames the non-final fields to comply with the naming convention "^[a-z][a-zA-Z0-9]*$" i.e. a lower case prefix followed by any sequence of alpha-numeric characters
Moves the string literals in the left-hand-side of equals() or equalsIgnoreCase() when checking for equality.
Simplifies arithmetic operations that an compound operator where possible.
This rule replaces the `concat()` method on `String`s with the `+` operator.
This rule replaces comparisons of length() or size() with 0 with a call to isEmpty(). Any occurrences of such a comparison will be replaced, regardless of surrounding control structure.
Transforms all possible for loops with iterators to a ForEach loop
Replaces occurrences of enhanced for-loops which are only used to initialize or return a boolean variable with `Stream::anyMatch`. The stream syntax is more concise and improves readability.
This rule refactors the enhanced for loops which are only being used for concatenating the elements of collections or arrays.
Replaces enhanced for-loops which are used to find an element within a collection by a stream and uses `Stream::findFirst` to find the result. By using the stream syntax, a multi-line control statement can be reduced to a single line.
This rule changes the type of local variables from StringBuffer() to StringBuilder().
Simplifies the code by replacing all occurrences of removeAll() which have the current collection as parameter with clear().
This rule replaces calls to indexOf() on instances of `String`s or `Collection`S with calls to the `contains()` method. `contains()` was introduced in Java 1.4 and helps to make the code more readable.
If map.put(..) is wrapped with a condition verifying the existence of an element one can use map.putIfAbsent(...) instead.
Converts anonymous inner classes to equivalent lambda expressions.
Wraps the initialization of a final collection with Collections.unmodifiable...()
Multiple field or variable declarations on the same line could cause confusion about their types and initial values. That also makes it harder to read and to understand the code. In order to improve readability, each field or variable should be declared on a separate line. This is recommended by the Code Conventions for the Java Programming Language.
Replaces the standard output statements with logger statements when possible.
This rule adds the @Override annotation to methods overriding or implementing parent class methods.
Replaces `Stream::forEach` with `Stream::collect` if the argument of the `forEach` statement is only used for adding elements to a list. This simplifies adding elements to a list.
Removes all class instantiations from String if its parameter is empty or a String.
Extracts a block from the body of the consumer of the Stream::forEach method and introduces Stream::map instead. This makes complicated code blocks easier to read and reuse.
This rule replaces the types on the local variable declarations with the var keyword introduced in Java 10.
Java 7 introduced the possibility to merge multiple catch clauses into a single multi-catch clause. Merging is only possible if the catch statements are identical.
The usage of Optional.get should be avoided in general because it can potentially throw a NoSuchElementException (it is likely to be deprecated in future releases). It is often the case that the invocation of Optional.get is wrapped by a condition that uses Optional.isPresent. Such cases can be replaced with the Optional.ifPresent(Consumer<? super T> consumer).
It is generally preferable better to use %n, which will produce the platform-specific line separator.
This rule transforms an if-Statement (without an else statement), which wraps the whole execution block of a Stream::forEach method into a call to Stream::filter with a lambda expression (Predicate) as parameter. This lambda is constructed using the expression from the if-Statement.
Replaces the infix operator `+` on String concatenation by StringBuilder::append
Replaces various String methods with their null-safe counterparts from StringUtils.
This rule adds the try-with-resources statement introduced in Java 7. Closing statements are removed as the construct takes care of that.