É melhor usar System.arraycopy (…) do que um loop for para copiar matrizes?

Quero criar uma nova matriz de objetos juntando duas matrizes menores.

Eles não podem ser nulos, mas o tamanho pode ser 0.

Não posso escolher entre essas duas maneiras: são equivalentes ou é mais eficiente (por exemplo, system.arraycopy () copia pedaços inteiros)?

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
System.arraycopy(publicThings, 0, things, 0, publicThings.length);
System.arraycopy(privateThings, 0, things,  publicThings.length, privateThings.length);

ou

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
for (int i = 0; i < things.length; i++) {
    if (i<publicThings.length){
        things[i] = publicThings[i]
    } else {
        things[i] = privateThings[i-publicThings.length]        
    }
}

A única diferença é a aparência do código?

EDITAR: obrigado pela pergunta vinculada, mas eles parecem ter uma discussão não resolvida:

É realmente mais rápido se it is not for native types: byte [], Object [], char []? em todos os outros casos, uma verificação de tipo é executada, qual seria o meu caso e, portanto, seria equivalente ... não?

Em outra pergunta vinculada, eles dizem que the size matters a lot, para tamanho> 24, ganha system.arraycopy (), para menos de 10, manual para loop é melhor ...

Agora estou realmente confuso.

public void testHardCopyBytes()
{
    byte[] bytes = new byte[0x5000000]; /*~83mb buffer*/
    byte[] out = new byte[bytes.length];
    for(int i = 0; i < out.length; i++)
    {
        out[i] = bytes[i];
    }
}

public void testArrayCopyBytes()
{
    byte[] bytes = new byte[0x5000000]; /*~83mb buffer*/
    byte[] out = new byte[bytes.length];
    System.arraycopy(bytes, 0, out, 0, out.length);
}

Eu sei que os testes JUnit não são realmente os melhores para benchmarking, mas
testHardCopyBytes levou 0,157s para ser concluído
e
testArrayCopyBytes levou 0,086s para ser concluído.

Acho que depende da máquina virtual, mas parece que ela copia blocos de memória em vez de copiar elementos de array único. Isso aumentaria absolutamente o desempenho.

EDIT:
Parece que o desempenho de System.arraycopy está em todo lugar. Quando Strings são usados ​​em vez de bytes e as matrizes são pequenas (tamanho 10), obtenho estes resultados:

    String HC:  60306 ns
    String AC:  4812 ns
    byte HC:    4490 ns
    byte AC:    9945 ns

Aqui está o que parece quando os arrays estão no tamanho 0x1000000. Parece que System.arraycopy definitivamente vence com arrays maiores.

    Strs HC:  51730575 ns
    Strs AC:  24033154 ns
    Bytes HC: 28521827 ns
    Bytes AC: 5264961 ns

Que peculiar!

Obrigado, Daren, por apontar que as referências são copiadas de maneira diferente. Isso tornou esse problema muito mais interessante!

Arrays.copyOf(T[], int)é mais fácil de ler. Internamente, ele usa o System.arraycopy()que é uma chamada nativa.

Você não pode obter isso mais rápido!

Depende da máquina virtual, mas System.arraycopy deve fornecer o mais próximo que você pode obter do desempenho nativo.

Eu trabalhei por 2 anos como um desenvolvedor Java para sistemas embarcados (onde o desempenho é uma grande prioridade) e em todos os lugares que System.arraycopy poderia ser usado, eu o usei / vi principalmente em código existente. É sempre preferível a loops quando o desempenho é um problema. Se o desempenho não for um grande problema, eu iria com o loop. Muito mais fácil de ler.

Em vez de depender de especulações e informações possivelmente desatualizadas, executei alguns benchmarks usando compasso de calibre. Na verdade, o Caliper vem com alguns exemplos, incluindo um CopyArrayBenchmarkque mede exatamente essa questão! Tudo que você precisa fazer é correr

mvn exec:java -Dexec.mainClass=com.google.caliper.runner.CaliperMain -Dexec.args=examples.CopyArrayBenchmark

Meus resultados são baseados no servidor VM de 64 bits Java HotSpot (TM) da Oracle, 1.8.0_31-b13, rodando em um MacBook Pro de meados de 2010 (macOS 10.11.6 com Intel Arrandale i7, 8 GiB de RAM). Não acredito que seja útil postar os dados de tempo brutos. Em vez disso, resumirei as conclusões com as visualizações de apoio.

Em suma:

• Escrever um forloop manual para copiar cada elemento em um array recém-instanciado nunca é vantajoso, seja para arrays curtos ou longos.
• Arrays.copyOf(array, array.length)e array.clone()ambos são consistentemente rápidos. Essas duas técnicas são quase idênticas em desempenho; qual você escolher é uma questão de gosto.
• System.arraycopy(src, 0, dest, 0, src.length)é quase tão rápido quanto e , mas não de forma consistente. (Veja o caso para 50000 s.) Por causa disso, e da verbosidade da chamada, eu recomendaria se você precisar de um controle fino sobre quais elementos são copiados e onde.Arrays.copyOf(array, array.length)array.clone()intSystem.arraycopy()

Aqui estão os gráficos de tempo:

A execução de métodos nativos Arrays.copyOf(T[], int)tem alguma sobrecarga, mas não significa que não seja rápida porque você a executa usando JNI.

A maneira mais fácil é escrever um benchmark e um teste.

Você pode verificar se Arrays.copyOf(T[], int)é mais rápido do que seu forloop normal .

O código de referência daqui : -

public void test(int copySize, int copyCount, int testRep) {
    System.out.println("Copy size = " + copySize);
    System.out.println("Copy count = " + copyCount);
    System.out.println();
    for (int i = testRep; i > 0; --i) {
        copy(copySize, copyCount);
        loop(copySize, copyCount);
    }
    System.out.println();
}

public void copy(int copySize, int copyCount) {
    int[] src = newSrc(copySize + 1);
    int[] dst = new int[copySize + 1];
    long begin = System.nanoTime();
    for (int count = copyCount; count > 0; --count) {
        System.arraycopy(src, 1, dst, 0, copySize);
        dst[copySize] = src[copySize] + 1;
        System.arraycopy(dst, 0, src, 0, copySize);
        src[copySize] = dst[copySize];
    }
    long end = System.nanoTime();
    System.out.println("Arraycopy: " + (end - begin) / 1e9 + " s");
}

public void loop(int copySize, int copyCount) {
    int[] src = newSrc(copySize + 1);
    int[] dst = new int[copySize + 1];
    long begin = System.nanoTime();
    for (int count = copyCount; count > 0; --count) {
        for (int i = copySize - 1; i >= 0; --i) {
            dst[i] = src[i + 1];
        }
        dst[copySize] = src[copySize] + 1;
        for (int i = copySize - 1; i >= 0; --i) {
            src[i] = dst[i];
        }
        src[copySize] = dst[copySize];
    }
    long end = System.nanoTime();
    System.out.println("Man. loop: " + (end - begin) / 1e9 + " s");
}

public int[] newSrc(int arraySize) {
    int[] src = new int[arraySize];
    for (int i = arraySize - 1; i >= 0; --i) {
        src[i] = i;
    }
    return src;
}

System.arraycopy()usa JNI (Java Native Interface) para copiar um array (ou partes dele), por isso é extremamente rápido, como você pode confirmar aqui

Não é possível que Arrays.copyOfseja mais rápido do que, System.arraycopypois esta é a implementação de copyOf:

public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

System.arraycopy()é uma chamada nativa que copia a operação diretamente na memória. A cópia de memória única seria sempre mais rápida do que o loop for