Java clean ups are run on the current document whenever it's saved. They can fix a wide variety of issues, from code style to programming mistakes, and can even modernize the sources based on new Java language features. Here is some information on the supported cleanups and the details of what they do.
Whenever a member (field or method) of a class is accessed from within the class,
prefix the access with this.
This is similar to how Python requires the programmer to access members using self.
For instance:
private int value;
public void getValue() {
return value;
}becomes:
private int value;
public void getValue() {
return this.value;
}Whenever there is a static variable or function, prefix the access with the name of the class that the static variable or function belongs to.
For instance:
import static java.lang.System.out;
public class MyClass {
public static final double FACTOR = 0.5;
public double getNumber(double value) {
out.println("moo");
return value * FACTOR;
}
}becomes:
import static java.lang.System.out;
public class MyClass {
public static final double FACTOR = 0.5;
public double getNumber(double value) {
System.out.println("moo");
return value * MyClass.FACTOR;
}
}When a method of a class that overrides a method from a parent class or provides an implementation for a method from an interface, add the @Override annotation.
For example:
public class MyRunner implements Runnable {
public void run() {
System.out.println("Hello, World!");
}
}becomes:
public class MyRunner implements Runnable {
@Override
public void run() {
System.out.println("Hello, World!");
}
}When a method is marked @deprecated in the Javadoc, but doesn't have the @Deprecated annotation, add the @Deprecated annotation.
This only works if the compiler has been configured to mark deprecated methods without the deprecated annotation
as an info/warning/error in the JDT settings.
For example:
/**
* Not used anymore, please stop using.
*
* @deprecated
*/
public boolean isAGoat() {
return false;
}becomes:
/**
* Not used anymore, please stop using.
*
* @deprecated
*/
@Deprecated
public boolean isAGoat() {
return false;
}Appropriate String concatenations will be converted into Java Text Blocks. Appropriate String concatenations must have at least 3 non-empty substrings with one per line and the Java level must be 15 or higher. Line comments for all substrings but the last line will be lost after conversion. Spaces at the end of substrings preceding the newline will result in \s being substituted while substrings that do not end with newlines will have a \ added at the end of the line to preserve concatenation.
For example:
String x = "" +
"public class A {\n" +
" public void m() {\n" +
" System.out.println(\"abc\");\n" +
" }\n" +
"}";becomes:
String x = """
public class A {
public void m() {
System.out.println("abc");
}
}""";Inverts calls to Object.equals(Object) and String.equalsIgnoreCase(String) to avoid useless null pointer exception.
The caller must be nullable and the parameter must not be nullable.
By avoiding null pointer exceptions, the behavior may change.
For example:
String message = getMessage();
boolean result1 = message.equals("text");
boolean result2 = message.equalsIgnoreCase("text");becomes:
String message = getMessage();
boolean result1 = "text".equals(message);
boolean result2 = "text".equalsIgnoreCase(message);Use the final modifier for variable declarations wherever it is possible.
For example:
private int i= 0;
public void foo(int j) {
int k, h;
h= 0;
}becomes:
private final int i= 0;
public void foo(final int j) {
final int k;
int h;
h= 0;
}Use pattern matching for the instanceof operator wherever possible. It is only applicable for Java level 15 or higher.
For example:
if (object instanceof Integer) {
Integer i = (Integer) object;
return i.intValue();
}becomes:
if (object instanceof Integer i) {
return i.intValue();
}Convert anonymous class declarations for functional interfaces to lambda expressions wherever possible. It is only applicable for Java level 8 or above.
For example:
IntConsumer c = new IntConsumer() {
@Override public void accept(int value) {
System.out.println(i);
}
};becomes:
IntConsumer c = i -> {
System.out.println(i);
};Convert switch statements to switch expressions wherever possible. It is only applicable for Java level 14 or above.
Note : Switch statements that use control statements such as nested switch statements, if/else blocks, for/while loops are not considered as is the case for return/continue statements. All cases of the switch statement must either have a last assignment statement that sets the same variable/field as other cases, or else has a throw statement. Fall-through is allowed between cases but only if there are no other statements in between. The switch statement must have a default case unless the switch expression is an enum type and all possible enum values are represented in the cases.
For example:
int i;
switch(j) {
case 1:
i = 3;
break;
case 2:
i = 4;
break;
default:
i = 0;
break;
}becomes:
int i = switch(j) {
case 1 -> 3;
case 2 -> 4;
default -> 0;
};Simplifies the finally block to use the try-with-resource statement.
For example:
final FileInputStream inputStream = new FileInputStream("out.txt");
try {
System.out.println(inputStream.read());
} finally {
inputStream.close();
}becomes:
final FileInputStream inputStream = new FileInputStream("out.txt");
try (inputStream) {
System.out.println(inputStream.read());
}Cleans up lambda expression wherever possible in the following ways:
-
Removes unnecessary parentheses.
For example:
(someString) -> someString.trim().toLowerCase();
becomes:
someString -> someString.trim().toLowerCase();
-
Converts lambda expression blocks to a single statement when possible.
For example:
someString -> {return someString.trim().toLowerCase();};
becomes:
someString -> someString.trim().toLowerCase();
-
Converts lambda expression to method reference.
For example:
() -> new ArrayList<>();
becomes:
ArrayList::new;
Performs the "Organize Imports" operation.
Note : Since clean ups are meant to be applied without user feedback (eg. prompts about ambiguous types), this may leave some types unresolved. To properly resolve these ambiguous types, one can do so manually (code actions, source actions), or by calling "Organize Imports" through the command palette / key binding (shift + alt + o).
For example:
package test1;
public class A {
public void test() {
List<String> a1;
Iterator<String> a2;
Map<String, String> a3;
Set<String> a4;
JarFile a5;
StringTokenizer a6;
Path a7;
URI a8;
HttpURLConnection a9;
InputStream a10;
Field a11;
Parser a12;
}
}becomes:
package test1;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URI;
import java.nio.file.Path;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.jar.JarFile;
public class A {
public void test() {
List<String> a1;
Iterator<String> a2;
Map<String, String> a3;
Set<String> a4;
JarFile a5;
StringTokenizer a6;
Path a7;
URI a8;
HttpURLConnection a9;
InputStream a10;
Field a11;
Parser a12;
}
}Rename unused loop variables, try-with-resource variables, catch parameters, lambda parameters, pattern variables to _.
For example:
J j = (a, b) -> System.out.println(a);
switch (r) {
case R(_, long l) -> {}
case R r2 -> {}
}becomes:
J j = (a, _) -> System.out.println(a);
switch (r) {
case R(_, _) -> {}
case R _ -> {}
}