Czy lepiej jest używać System.arraycopy (…) niż pętli for do kopiowania tablic?

Chcę utworzyć nową tablicę obiektów składającą dwie mniejsze tablice.

Nie mogą być zerowe, ale rozmiar może wynosić 0.

Nie mogę wybrać między tymi dwoma sposobami: czy są one równoważne, czy też jeden bardziej wydajny (na przykład system.arraycopy () kopiuje całe fragmenty)?

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

lub

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

Czy jedyną różnicą jest wygląd kodu?

EDYCJA: dziękuję za powiązane pytanie, ale wydaje się, że mają nierozwiązaną dyskusję:

Czy jest to naprawdę szybsze, jeśli it is not for native types: bajt [], obiekt [], znak []? we wszystkich innych przypadkach wykonywana jest kontrola typu, co byłoby moim przypadkiem, a więc byłoby równoważne ... nie?

W innym powiązanym pytaniu mówią, że the size matters a lotdla rozmiaru> 24 wygrywa system.arraycopy (), dla mniejszych niż 10, ręczna pętla jest lepsza ...

Teraz jestem naprawdę zdezorientowany.

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

Wiem, że testy JUnit nie są najlepsze do testów porównawczych, ale
wykonanie testu testHardCopyBytes zajęło 0,157 s,
a
testArrayCopyBytes - 0,086 s.

Myślę, że zależy to od maszyny wirtualnej, ale wygląda na to, że kopiuje bloki pamięci zamiast kopiować pojedyncze elementy tablicy. To zdecydowanie zwiększyłoby wydajność.

EDYCJA:
Wygląda na to, że wydajność System.arraycopy jest wszędzie. Gdy zamiast bajtów używane są ciągi znaków, a tablice są małe (rozmiar 10), otrzymuję następujące wyniki:

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

Oto, jak to wygląda, gdy tablice mają rozmiar 0x1000000. Wygląda na to, że System.arraycopy zdecydowanie wygrywa z większymi tablicami.

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

Jakie to dziwne!

Dzięki, Daren, za zwrócenie uwagi, że referencje kopiują się inaczej. To sprawiło, że był to znacznie bardziej interesujący problem!

Arrays.copyOf(T[], int)jest łatwiejszy do odczytania. Używa wewnętrznego połączenia, System.arraycopy()które jest rodzimym połączeniem.

Nie da się tego szybciej!

Zależy to od maszyny wirtualnej, ale System.arraycopy powinien zapewniać najbliższą wydajność natywną.

Pracowałem przez 2 lata jako programista Java dla systemów wbudowanych (gdzie wydajność jest ogromnym priorytetem) i wszędzie tam, gdzie można użyć System.arraycopy, najczęściej go używałem / widziałem w istniejącym kodzie. W przypadku problemów z wydajnością jest zawsze preferowana zamiast pętli. Jeśli wydajność nie jest dużym problemem, wybrałbym pętlę. O wiele łatwiejsze do odczytania.

Zamiast polegać na spekulacjach i prawdopodobnie nieaktualnych informacjach, przeprowadziłem testy porównawcze, używając suwmiarka. W rzeczywistości Caliper zawiera kilka przykładów, w tym odpowiedź, CopyArrayBenchmarkktóra dokładnie mierzy to pytanie! Wszystko, co musisz zrobić, to biec

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

Moje wyniki są oparte na 64-bitowej maszynie wirtualnej Oracle Java HotSpot (TM) Server VM, 1.8.0_31-b13, działającej na MacBooku Pro z połowy 2010 roku (macOS 10.11.6 z Intel Arrandale i7, 8 GiB RAM). Nie wierzę, że publikowanie surowych danych dotyczących czasu jest przydatne. Raczej podsumuję wnioski za pomocą pomocniczych wizualizacji.

W podsumowaniu:

• Pisanie ręcznej forpętli w celu skopiowania każdego elementu do nowo utworzonej tablicy nigdy nie jest korzystne, zarówno w przypadku krótkich, jak i długich tablic.
• Arrays.copyOf(array, array.length)i array.clone()oba są konsekwentnie szybkie. Te dwie techniki są prawie identyczne pod względem wydajności; który wybierzesz to kwestia gustu.
• System.arraycopy(src, 0, dest, 0, src.length)jest prawie tak szybki jak i , ale nie do końca konsekwentnie. (Zobacz przypadek dla 50000 s.) Z tego powodu i szczegółowości wywołania polecam, jeśli potrzebujesz dokładnej kontroli nad tym, które elementy są kopiowane i gdzie.Arrays.copyOf(array, array.length)array.clone()intSystem.arraycopy()

Oto wykresy czasowe:

Wykonywanie metod natywnych, takich jak, Arrays.copyOf(T[], int)wiąże się z pewnym narzutem, ale nie oznacza to, że nie jest szybkie, ponieważ wykonujesz je za pomocą JNI.

Najłatwiej jest napisać benchmark i przetestować.

Możesz sprawdzić, czy Arrays.copyOf(T[], int)jest szybszy niż normalna forpętla.

Kod testu porównawczego stąd : -

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()używa JNI (Java Native Interface) do kopiowania tablicy (lub jej części), więc jest niesamowicie szybki, co możesz potwierdzić tutaj

Nie jest możliwe, żeby Arrays.copyOfto było szybsze niż, System.arraycopyponieważ jest to implementacja 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()jest rodzimym wywołaniem, które wykonuje operację kopiowania bezpośrednio w pamięci. Pojedyncza kopia w pamięci byłaby zawsze szybsza niż twoja pętla for