.toArray (nova MyClass [0]) ou .toArray (nova MyClass [myList.size ()])?

Supondo que eu tenho um ArrayList

ArrayList<MyClass> myList;

E eu quero ligar para oArray, existe uma razão de desempenho para usar

MyClass[] arr = myList.toArray(new MyClass[myList.size()]);

sobre

MyClass[] arr = myList.toArray(new MyClass[0]);

?

Eu prefiro o segundo estilo, já que é menos detalhado, e presumi que o compilador garantirá que a matriz vazia não seja realmente criada, mas estou pensando se isso é verdade.

Obviamente, em 99% dos casos, não faz diferença de uma maneira ou de outra, mas eu gostaria de manter um estilo consistente entre meu código normal e meus loops internos otimizados ...

Por outro lado, a versão mais rápida, no Hotspot 8, é:

MyClass[] arr = myList.toArray(new MyClass[0]);

Eu executei um micro benchmark usando jmh, os resultados e o código estão abaixo, mostrando que a versão com uma matriz vazia supera consistentemente a versão com uma matriz presized. Observe que, se você puder reutilizar uma matriz existente do tamanho correto, o resultado poderá ser diferente.

Resultados de benchmark (pontuação em microssegundos, menor = melhor):

Benchmark                      (n)  Mode  Samples    Score   Error  Units
c.a.p.SO29378922.preSize         1  avgt       30    0.025 ▒ 0.001  us/op
c.a.p.SO29378922.preSize       100  avgt       30    0.155 ▒ 0.004  us/op
c.a.p.SO29378922.preSize      1000  avgt       30    1.512 ▒ 0.031  us/op
c.a.p.SO29378922.preSize      5000  avgt       30    6.884 ▒ 0.130  us/op
c.a.p.SO29378922.preSize     10000  avgt       30   13.147 ▒ 0.199  us/op
c.a.p.SO29378922.preSize    100000  avgt       30  159.977 ▒ 5.292  us/op
c.a.p.SO29378922.resize          1  avgt       30    0.019 ▒ 0.000  us/op
c.a.p.SO29378922.resize        100  avgt       30    0.133 ▒ 0.003  us/op
c.a.p.SO29378922.resize       1000  avgt       30    1.075 ▒ 0.022  us/op
c.a.p.SO29378922.resize       5000  avgt       30    5.318 ▒ 0.121  us/op
c.a.p.SO29378922.resize      10000  avgt       30   10.652 ▒ 0.227  us/op
c.a.p.SO29378922.resize     100000  avgt       30  139.692 ▒ 8.957  us/op

Para referência, o código:

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
public class SO29378922 {
  @Param({"1", "100", "1000", "5000", "10000", "100000"}) int n;
  private final List<Integer> list = new ArrayList<>();
  @Setup public void populateList() {
    for (int i = 0; i < n; i++) list.add(0);
  }
  @Benchmark public Integer[] preSize() {
    return list.toArray(new Integer[n]);
  }
  @Benchmark public Integer[] resize() {
    return list.toArray(new Integer[0]);
  }
}

Você pode encontrar resultados semelhantes, análise completa e discussão na publicação do blog Matrizes de Sabedoria dos Antigos . Para resumir: o compilador JVM e JIT contém várias otimizações que permitem criar e inicializar de maneira barata uma nova matriz de tamanho correto e essas otimizações não podem ser usadas se você mesmo criar a matriz.

A partir do ArrayList no Java 5 , o array já estará preenchido se tiver o tamanho certo (ou for maior). Consequentemente

MyClass[] arr = myList.toArray(new MyClass[myList.size()]);

criará um objeto de matriz, preencha-o e retorne-o para "arr". Por outro lado

MyClass[] arr = myList.toArray(new MyClass[0]);

criará duas matrizes. O segundo é uma matriz de MyClass com comprimento 0. Portanto, há uma criação de objeto para um objeto que será descartado imediatamente. Na medida em que o código-fonte sugere, o compilador / JIT não pode otimizar este para que ele não seja criado. Além disso, o uso do objeto de comprimento zero resulta em conversão (ões) dentro do método toArray () -.

Veja a fonte de ArrayList.toArray ():

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

Use o primeiro método para que apenas um objeto seja criado e evite vazamentos (implícitos, porém caros).

Na inspeção JetBrains Intellij Idea:

Existem dois estilos para converter uma coleção em uma matriz: usando uma matriz pré-dimensionada (como c.toArray (nova String [c.size ()]) ) ou usando uma matriz vazia (como c.toArray (nova String [ 0]) .

Nas versões Java mais antigas, era recomendável usar matriz pré-dimensionada, pois a chamada de reflexão necessária para criar uma matriz com tamanho adequado era bastante lenta. No entanto, desde as atualizações tardias do OpenJDK 6, essa chamada foi intrinsecificada, tornando o desempenho da versão do array vazio o mesmo e, às vezes, ainda melhor, comparado à versão pré-dimensionada. A passagem de matriz pré-dimensionada também é perigosa para uma coleção simultânea ou sincronizada, pois é possível uma corrida de dados entre o tamanho e a chamada toArray, o que pode resultar em nulos extras no final da matriz, se a coleção tiver sido reduzida ao mesmo tempo durante a operação.

Essa inspeção permite seguir o estilo uniforme: usando uma matriz vazia (recomendada em Java moderno) ou usando uma matriz pré-dimensionada (que pode ser mais rápida em versões Java mais antigas ou JVMs não baseadas em HotSpot).

As JVMs modernas otimizam a construção de matriz reflexiva nesse caso, portanto a diferença de desempenho é pequena. Nomear a coleção duas vezes nesse código padrão não é uma boa idéia, portanto, evitaria o primeiro método. Outra vantagem do segundo é que ele trabalha com coleções sincronizadas e simultâneas. Se você quiser otimizar, reutilize a matriz vazia (matrizes vazias são imutáveis ​​e podem ser compartilhadas) ou use um criador de perfil (!).

O toArray verifica se a matriz passada é do tamanho certo (ou seja, grande o suficiente para caber nos elementos da sua lista) e, se sim, usa isso. Consequentemente, se o tamanho da matriz for menor que o necessário, uma nova matriz será criada reflexivamente.

No seu caso, uma matriz de tamanho zero é imutável; portanto, ela pode ser elevada com segurança a uma variável final estática, o que pode tornar seu código um pouco mais limpo, o que evita a criação da matriz em cada chamada. Uma nova matriz será criada dentro do método de qualquer maneira, portanto é uma otimização de legibilidade.

Indiscutivelmente, a versão mais rápida é passar a matriz com um tamanho correto, mas, a menos que você possa provar que esse código é um gargalo de desempenho, prefira a legibilidade ao tempo de execução, até que seja provado o contrário.

O primeiro caso é mais eficiente.

Isso ocorre porque no segundo caso:

MyClass[] arr = myList.toArray(new MyClass[0]);

o tempo de execução realmente cria uma matriz vazia (com tamanho zero) e, em seguida, dentro do método toArray cria outra matriz para ajustar os dados reais. Essa criação é feita usando reflexão usando o seguinte código (extraído de jdk1.5.0_10):

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        a = (T[])java.lang.reflect.Array.
    newInstance(a.getClass().getComponentType(), size);
System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

Ao usar o primeiro formulário, você evita a criação de uma segunda matriz e também o código de reflexão.

O segundo é marginalmente mais legível, mas há tão pouca melhoria que não vale a pena. O primeiro método é mais rápido, sem desvantagens no tempo de execução, e é isso que eu uso. Mas eu escrevo da segunda maneira, porque é mais rápido digitar. Em seguida, meu IDE o sinaliza como um aviso e se oferece para corrigi-lo. Com um único toque de tecla, ele converte o código do segundo tipo para o primeiro.

Usar 'toArray' com a matriz do tamanho correto terá um desempenho melhor, pois a alternativa criará primeiro a matriz com tamanho zero e depois a matriz com o tamanho correto. No entanto, como você diz, a diferença provavelmente será insignificante.

Além disso, observe que o compilador javac não executa nenhuma otimização. Atualmente, todas as otimizações são executadas pelos compiladores JIT / HotSpot em tempo de execução. Não conheço nenhuma otimização em torno de 'toArray' em nenhuma JVMs.

A resposta para sua pergunta, portanto, é basicamente uma questão de estilo, mas por uma questão de consistência deve fazer parte de todos os padrões de codificação aos quais você adere (documentado ou não).

código de amostra para inteiro:

Integer[] arr = myList.toArray(new integer[0]);