Description Fabrice Tiercelin 2020-09-23 01:27:04 EDT

Replaces for loops to use Arrays.fill() where possible.

Given:
for (int i = 0; i < array.length; i++) {
    array[i] = true;
}

When:
Clean up the code enabling "Use Arrays.fill()"

Then:
Arrays.fill(array, true);


This feature is a part of the AutoRefactor plugin immigration into Eclipse
+--------------------------------------------------------------------+-----+
| Rule in AutoRefactor                                               |     |
+--------------------------------------------------------------------+-----+
| Add brackets to control statement                                  | OK  |
| AutoBoxing rather than explicit method                             | OK  |
| Collection.addAll() rather than list creation                      | OK  |
| Diamond operator                                                   | OK  |
| Improve lambda expressions                                         | OK  |
| Lazy logical rather than eager                                     | OK  |
| Method on map rather than method on keyset                         | OK  |
| Merge conditional statements                                       | OK  |
| Number suffix in uppercase                                         | OK  |
| Objects equals rather than equals and null check                   | OK  |
| Precompiles the regular expressions                                | OK  |
| Push negation down                                                 | 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  |
| String rather than new string                                      | OK  |
| Unboxing rather than explicit method                               | OK  |
| Arrays.fill() rather than loop                                     | ... |
| Collapse if statements                                             | ... |
| Inited map rather than new map and Map.putAll()                    | ... |
| Remove super() call in constructor                                 | ... |
| Add underscore for each thousand in number literals when it is...  | ko  |
| 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  |
| AssertJ                                                            | ko  |
| Assign rather than control workflow then assign anyway             | ko  |
| Assign rather than ternary filter then assign anyway               | ko  |
| Atomic object rather than mono index array                         | 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  |
| Char primitive rather than wrapper                                 | 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  |
| 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  |
| 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  |
| Jupiter asserts                                                    | ko  |
| Lambda expression rather than comparator                           | ko  |
| Literal rather than boolean constant                               | ko  |
| Local variable rather than field                                   | ko  |
| Log parameters rather than log message                             | ko  |
| Long primitive rather than wrapper                                 | ko  |
| Make inner class static if it doesn't use top level class members  | ko  |
| Map.entrySet() rather than Map.keySet() and value search           | ko  |
| Move common inner if statement from then/else clauses around ou... | ko  |
| Moves increment or decrement outside an expression when possible   | ko  |
| Multi-catch                                                        | ko  |
| Named method rather than log level parameter                       | ko  |
| No assignment in if condition                                      | ko  |
| No loop iteration rather than empty 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  |
| Reduce indentation                                                 | ko  |
| Refactors a true or a false assertion with respectively an AND     | ko  |
| Remove empty if                                                    | ko  |
| Remove empty lines                                                 | ko  |
| Remove fields default values                                       | ko  |
| Remove overridden assignment                                       | ko  |
| Remove parenthesis                                                 | ko  |
| Remove unchecked exceptions from throws clause                     | ko  |
| Remove unnecessary local before return                             | ko  |
| Remove useless block                                               | ko  |
| Remove useless empty check before a for loop                       | ko  |
| Removes useless lone continue at the end of a loop                 | ko  |
| Remove empty statements                                            | ko  |
| Replace for loop with Collections.disjoint(Collection, Collection) | ko  |
| Replace String concatenation by StringBuilder when possible        | 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.join() rather than loop                                     | 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 java.nio.* classes instead of java.io.* classes                | ko  |
| Use String.contains()                                              | ko  |
| Use try-with-resource                                              | ko  |
| Variable inside if rather than above                               | ko  |
| XOR rather than duplicate conditions                               | ko  |
+--------------------------------------------------------------------+-----+