Description Fabrice Tiercelin 2019-08-23 14:40:51 EDT

Improve lambda expressions if the JVM is >= 1.8 as follows:

Given
(someString) -> someString.trim().toLowerCase();
someString -> {return someString.trim().toLowerCase();};
someString -> {return someString.trim().toLowerCase() + \"bar\";};
() -> new ArrayList<>();
date -> date.getTime();

When
Clean up the code enabling "Simplify lambda expression and method reference syntax"

Then
someString -> someString.trim().toLowerCase();
someString -> someString.trim().toLowerCase();
someString -> (someString.trim().toLowerCase() + \"bar\");
ArrayList::new;
Date::getTime;


This feature is a part of the AutoRefactor plugin immigration in Eclipse
+--------------------------------------------------------------------+-----+
| Rule in AutoRefactor                                               |     |
+--------------------------------------------------------------------+-----+
| Add brackets to control statement                                  | OK  |
| AutoBoxing rather than explicit method                             | OK  |
| Diamond operator                                                   | OK  |
| Remove semi-colons                                                 | OK  |
| Remove unnecessary casts                                           | OK  |
| Remove unneeded this expressions                                   | OK  |
| Remove useless modifiers                                           | OK  |
| Simple name rather than qualified name                             | OK  |
| Unboxing rather than explicit method                               | OK  |
| Improve lambda expressions                                         | ... |
| Aggregate constructor rather than GWT method                       | ko  |
| All in one method rather than loop                                 | ko  |
| Android ViewHolder                                                 | ko  |
| Android WakeLock                                                   | ko  |
| Annotation                                                         | ko  |
| ArrayDeque rather than Stack                                       | ko  |
| ArrayList rather than LinkedList                                   | ko  |
| ArrayList rather than Vector                                       | ko  |
| Big number                                                         | ko  |
| Boolean                                                            | ko  |
| Boolean constant rather than valueOf()                             | ko  |
| Boolean equals() rather than null check                            | ko  |
| Boolean primitive rather than wrapper                              | ko  |
| Brackets rather than array instantiation                           | ko  |
| Break rather than passive loops                                    | ko  |
| Byte primitive rather than wrapper                                 | ko  |
| Capitalize lower case 'l' -> 'L' for long number literals          | ko  |
| Char primitive rather than wrapper                                 | ko  |
| Collapse if statements                                             | ko  |
| Collection.contains() rather than loop                             | ko  |
| Collection.containsAll() rather than loop                          | ko  |
| Collections APIs rather than Vector pre-Collections APIs           | ko  |
| Comments                                                           | ko  |
| Comparison to 0 rather than 1 or -1                                | ko  |
| Declaration outside loop rather than inside                        | ko  |
| Do/while rather than duplicate code                                | ko  |
| Do/while rather than while                                         | ko  |
| Double compare rather than equality                                | ko  |
| Double primitive rather than wrapper                               | ko  |
| Else rather than opposite condition                                | ko  |
| Empty test rather than size                                        | ko  |
| End of method rather than return                                   | ko  |
| EnumMap rather than HashMap for enum keys                          | ko  |
| EnumSet rather than HashSet for enum types                         | ko  |
| Equals on constant rather than on variable                         | ko  |
| Extract common code in if else statement                           | ko  |
| Float primitive rather than wrapper                                | ko  |
| Generic list rather than raw list                                  | ko  |
| Generic map rather than raw map                                    | ko  |
| HashMap rather than Hashtable                                      | ko  |
| HashMap rather than TreeMap                                        | ko  |
| HashSet rather than TreeSet                                        | ko  |
| HotSpot intrinsiced APIs                                           | ko  |
| If rather than two switch cases                                    | ko  |
| If rather than while and falls through                             | ko  |
| if-elseif                                                          | ko  |
| Implicit default constructor rather than written one               | ko  |
| Inited collection rather than new collection and Collection.add... | ko  |
| Inited map rather than new map and Map.putAll()                    | ko  |
| Inline code rather than peremptory condition                       | ko  |
| Int primitive rather than wrapper                                  | ko  |
| Java 7 hash rather than Eclipse Java 6 hash                        | ko  |
| JUnit asserts                                                      | ko  |
| Lambda expression rather than comparator                           | ko  |
| Lazy logical rather than eager                                     | ko  |
| Literal rather than boolean constant                               | ko  |
| Log parameters rather than log message                             | ko  |
| Long primitive rather than wrapper                                 | ko  |
| Map.entrySet() rather than Map.keySet() and value search           | ko  |
| Merge conditional statements                                       | ko  |
| Method on map rather than method on keyset                         | ko  |
| Move common inner if statement from then/else clauses around ou... | ko  |
| Multi-catch                                                        | ko  |
| Named method rather than log level parameter                       | ko  |
| No assignment in if condition                                      | ko  |
| Objects equals rather than equals and null check                   | ko  |
| One code that falls through rather than redundant blocks           | ko  |
| One condition rather than unreachable block                        | ko  |
| One if rather than duplicate blocks that fall through              | ko  |
| Opposite comparison rather than negative expression                | ko  |
| Opposite condition rather than duplicate condition                 | ko  |
| OR condition rather than redundant clauses                         | ko  |
| Primitive wrapper creation                                         | ko  |
| Push negation down                                                 | ko  |
| Remove empty if                                                    | ko  |
| Remove empty lines                                                 | ko  |
| Remove fields default values                                       | ko  |
| Remove overriden assignment                                        | ko  |
| Remove super() call in constructor                                 | ko  |
| Remove unchecked exceptions from throws clause                     | ko  |
| Remove unnecessary local before return                             | ko  |
| Remove useless block                                               | ko  |
| Remove useless null checks                                         | ko  |
| Removes empty statements                                           | ko  |
| Set rather than List                                               | ko  |
| Set rather than map                                                | ko  |
| Short primitive rather than wrapper                                | ko  |
| Simplify expressions                                               | ko  |
| Single declarations rather than multi declaration                  | ko  |
| Standard method rather than Library method                         | ko  |
| Static constant rather than instance constant                      | ko  |
| String                                                             | ko  |
| String rather than new string                                      | ko  |
| String.valueOf() rather than concatenation                         | ko  |
| StringBuilder                                                      | ko  |
| StringBuilder method call rather than reassignment                 | ko  |
| StringBuilder rather than StringBuffer                             | ko  |
| Super call rather than useless overriding                          | ko  |
| Switch                                                             | ko  |
| Ternary operator rather than duplicate conditions                  | ko  |
| TestNG asserts                                                     | ko  |
| Update set rather than testing first                               | ko  |
| Use String.contains()                                              | ko  |
| Use try-with-resource                                              | ko  |
| Work with null checked expressions first                           | ko  |
| XOR rather than duplicate conditions                               | ko  |
+--------------------------------------------------------------------+-----+