配列をコピーするためのforループよりもSystem.arraycopy（…）を使用する方が良いですか？

Question 1

2つの小さな配列をまとめてオブジェクトの新しい配列を作成したいと思います。

nullにすることはできませんが、サイズは0にすることができます。

これら2つの方法を選択することはできません。それらは同等ですか、それとももう1つ効率的ですか（たとえば、system.arraycopy（）はチャンク全体をコピーします）？

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);

または

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]        
    }
}

唯一の違いはコードの外観ですか？

編集：リンクされた質問に感謝しますが、彼らは未解決の議論を持っているようです：

it is not for native typesバイト[]、オブジェクト[]、文字[]の場合、本当に高速ですか？他のすべてのケースでは、タイプチェックが実行されます。これは私のケースなので、同等です...いいえ？

別のリンクされた質問で、彼らはthe size matters a lot、サイズが> 24のsystem.arraycopy（）が勝つ場合、10より小さい場合は、手動forループの方が良いと述べています...

今、私は本当に混乱しています。

Question 2

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);
}

JUnitテストは実際にはベンチマークに最適ではないことを知っていますが、
testHardCopyBytesは完了するまで
に
0.157秒かかり、testArrayCopyBytesは完了するまでに0.086秒かかりました。

それは仮想マシンに依存すると思いますが、単一の配列要素をコピーするのではなく、メモリのブロックをコピーするように見えます。これは絶対にパフォーマンスを向上させます。

編集：
System.arraycopyのパフォーマンスはどこにでもあるようです。バイトの代わりに文字列が使用され、配列が小さい（サイズ10）場合、次の結果が得られます。

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

配列のサイズが0x1000000の場合、次のようになります。System.arraycopyは間違いなく大きな配列で勝つようです。

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

なんて奇妙なことでしょう。

参照のコピーが異なることを指摘してくれたDarenに感謝します。これにより、これはより興味深い問題になりました。

Question 3

Arrays.copyOf(T[], int)読みやすいです。内部的にはSystem.arraycopy()ネイティブコールです。

あなたはそれを速く得ることはできません！

Question 4

それは仮想マシンに依存しますが、System.arraycopyは、ネイティブパフォーマンスに到達できる最も近いものを提供します。

私は組み込みシステム（パフォーマンスが最優先事項）のJava開発者として2年間働いており、System.arraycopyを使用できるところならどこでも使用できます。パフォーマンスが問題になる場合は、ループよりも常に推奨されます。パフォーマンスが大きな問題でない場合は、ループを使用します。はるかに読みやすい。

Question 5

憶測やおそらく時代遅れの情報に依存する代わりに、私はいくつかのベンチマークを実行しましたキャリパー。実際、Caliperには、CopyArrayBenchmarkこの質問を正確に測定するを含む、いくつかの例が付属しています。あなたがしなければならないすべては実行されます

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

私の結果は、2010年半ばのMacBook Pro（Intel Arrandale i7、8 GiB RAMを搭載したmacOS 10.11.6）で実行されているOracleのJava HotSpot（TM）64ビットサーバーVM、1.8.0_31-b13に基づいています。私は生のタイミングデータを投稿するのが便利だとは思いません。むしろ、サポートする視覚化で結論を要約します。

要約すれば：

手動のforループを記述して、各要素を新しくインスタンス化された配列にコピーすることは、短い配列でも長い配列でも、決して有利ではありません。
Arrays.copyOf(array, array.length)そしてarray.clone()両方とも一貫して高速です。これら2つの手法のパフォーマンスはほぼ同じです。どちらを選ぶかは好みの問題です。
System.arraycopy(src, 0, dest, 0, src.length)およびとほぼ同じくらい高速ですが、一貫性はありません。（50000 秒のケースを参照してください。）そのため、呼び出しの冗長性のため、どの要素をどこにコピーするかを細かく制御する必要があるかどうかをお勧めします。Arrays.copyOf(array, array.length)array.clone()intSystem.arraycopy()

タイミングプロットは次のとおりです。

Question 6

のようなネイティブメソッドを実行Arrays.copyOf(T[], int)するとオーバーヘッドが発生しますが、JNIを使用して実行しているため高速ではないという意味ではありません。

最も簡単な方法は、ベンチマークとテストを作成することです。

Arrays.copyOf(T[], int)通常のforループよりも速いことを確認できます。

ここからのベンチマークコード：-

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()ここで確認できるように、JNI（Java Native Interface）を使用して配列（またはその一部）をコピーするので、非常に高速です。

Question 7

これはの実装であるため、これArrays.copyOfよりも高速にすることはできません。 System.arraycopycopyOf

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;
}

Question 8

System.arraycopy()メモリで直接コピー操作を行うネイティブコールです。シングルメモリコピーは、常にforループよりも高速です。