Inefficient use of
toArray with non-zero sized array argument JAVA-P0335
Performance
Major
5 months ago
—
2 years old
new org.sonar.cxx.sslr.internal.vm.Instruction[result.size()] is less efficient than using a zero sized array here
50 for (var subExpression : subExpressions) {
51 Instruction.addAll(result, compiler.compile(subExpression));
52 }
53 return result.toArray(new Instruction[result.size()]);54 }
55
56 @Overridenew org.sonar.cxx.sslr.internal.vm.Instruction[instructions.size()] is less efficient than using a zero sized array here
58 }
59
60 // Link
61 var result = instructions.toArray(new Instruction[instructions.size()]);62 for (int i = 0; i < result.length; i++) {
63 var instruction = result[i];
64 if (instruction instanceof RuleRefExpression) {new com.sonar.cxx.sslr.api.Token[tokens.size()] is less efficient than using a zero sized array here
58 private boolean ignoreErrors = false;
59
60 public static ParseNode parse(List<Token> tokens, CompiledGrammar grammar) {
61 var inputTokens = tokens.toArray(new Token[tokens.size()]); 62
63 var errorLocatingHandler = new ErrorLocatingHandler();
64 var machine = new Machine(null, inputTokens, grammar.getInstructions(), errorLocatingHandler);new org.sonar.cxx.sslr.channel.CodeReaderFilter[codeReaderFilters.size()] is less efficient than using a zero sized array here
58 */
59 @SuppressWarnings("rawtypes")
60 public CodeReaderFilter[] getCodeReaderFilters() {
61 return codeReaderFilters.toArray(new CodeReaderFilter[codeReaderFilters.size()]);62 }
63
64 /**new org.sonar.cxx.sslr.channel.Channel[builder.channels.size()] is less efficient than using a zero sized array here
33 private final Channel<O>[] channels;
34
35 private ChannelDispatcher(Builder builder) {
36 this.channels = builder.channels.toArray(new Channel[builder.channels.size()]); 37 this.failIfNoChannelToConsumeOneCharacter = builder.failIfNoChannelToConsumeOneCharacter;
38 }
39
Description
This method uses toArray with a non-zero sized array argument. This is less efficient than passing a zero-sized array.
This method invokes toArray on a Collection object, and passes in an array with a size greater than zero as an argument. It used to be that this was faster than providing an array of size zero (new Type[0]) in older versions of Java prior to 6. This is because the cost of performing reflection operations was quite high in old Java versions.
This is no longer the case, and providing a zero sized array is now just as fast (or even faster) than providing an array of the same size as the original collection. It is now generally better to use a zero-length array as the argument to toArray.
Bad Practice
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer[] arr1 = list.toArray(new Integer[list.size()]); // Inefficient
Recommended
Integer[] arr2 = list.toArray(new Integer[0]); // Better