অ্যারে অনুলিপি করার জন্য লুপের চেয়ে System.arraycopy (…) ব্যবহার করা কি ভাল?

Question 1

আমি দুটি নতুন অ্যারে একসাথে অবজেক্টগুলির একটি নতুন অ্যারে তৈরি করতে চাই।

এগুলি শূন্য হতে পারে না, তবে আকার 0 হতে পারে।

আমি এই দুটি উপায়ের মধ্যে চয়ন করতে পারি না: সেগুলি কি সমতুল্য বা আরও কার্যকর (উদাহরণস্বরূপ 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 সিস্টেম.আররেইকপি () জিতবে, 10 এর চেয়ে কমের জন্য লুপের জন্য ম্যানুয়াল আরও ভাল ...

এখন আমি সত্যিই বিভ্রান্ত।

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

আমি জানি জুনিট পরীক্ষা সত্যই বেঞ্চমার্কিংয়ের জন্য সেরা নয়, তবে
টেস্টহার্ডকপিটাইটস সম্পন্ন করতে 0.157 সেকেন্ড নিয়েছে
এবং
টেস্ট অ্যারেকপি বাইটসগুলি সম্পন্ন করতে 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

কত অদ্ভুত!

রেফারেন্সগুলি আলাদাভাবে অনুলিপি করে দেখানোর জন্য ড্যারেন ধন্যবাদ। এটি আরও অনেক আকর্ষণীয় সমস্যা তৈরি করেছে!

Question 3

Arrays.copyOf(T[], int)পড়া সহজ। ইন্টার্নি এটি ব্যবহার করেSystem.arraycopy() যা একটি নেটিভ কল।

আপনি এটি দ্রুত পেতে পারবেন না!

Question 4

এটি ভার্চুয়াল মেশিনের উপর নির্ভর করে, তবে System.arraycopy আপনাকে দেশীয় কার্য সম্পাদন করতে পারে এমন নিকটতম স্থানটি দেবে।

আমি এম্বেড থাকা সিস্টেমগুলির জন্য জাভা বিকাশকারী হিসাবে 2 বছর ধরে কাজ করেছি (যেখানে কর্মক্ষমতা একটি বিশাল অগ্রাধিকার) এবং যেখানেই System.arraycopy ব্যবহার করা যেতে পারে, আমি বেশিরভাগই এটি ব্যবহার করেছি / এটি বিদ্যমান কোডটিতে ব্যবহার করে দেখেছি। কর্মক্ষমতা যখন ইস্যু হয় তখন লুপের চেয়ে সর্বদা পছন্দ করা হয়। পারফরম্যান্স যদি কোনও বড় সমস্যা না হয় তবে আমি লুপটি সহ যাব। পড়তে অনেক সহজ।

Question 5

অনুমান এবং সম্ভবত পুরানো তথ্যের উপর নির্ভর করার পরিবর্তে আমি কয়েকটি বেঞ্চমার্ক ব্যবহার করে চালিয়েছি ক্যালিপার। প্রকৃতপক্ষে, ক্যালিপার কিছু উদাহরণ নিয়ে আসেন, যার মধ্যে রয়েছে CopyArrayBenchmarkএই প্রশ্নটির সঠিক সমাধান! আপনাকে যা করতে হবে তা চালাতে হবে

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

আমার ফলাফলগুলি অরাকলের জাভা হটস্পট (টিএম) 64-বিট সার্ভার ভিএম, 1.8.0_31-বি 13 এর উপর ভিত্তি করে 2010 সালের মাঝামাঝি ম্যাকবুক প্রো (ইন্টেল আরানডেল আই 7, 8 জিবি র‌্যাম সহ 10.11.6) চলছে। আমি বিশ্বাস করি না যে কাঁচা সময় ডেটা পোস্ট করা দরকারী useful বরং, আমি সমর্থনকারী ভিজ্যুয়ালাইজেশনের সাথে সিদ্ধান্তগুলি সংক্ষিপ্ত করব।

সংক্ষেপে:

forএকটি নতুন তাত্ক্ষণিক অ্যারেতে প্রতিটি উপাদানকে অনুলিপি করার জন্য একটি ম্যানুয়াল লুপ লেখা কখনই সুবিধাজনক হয় না, স্বল্প অ্যারে বা দীর্ঘ অ্যারে হোক।
Arrays.copyOf(array, array.length)এবং array.clone()উভয়ই ধারাবাহিকভাবে দ্রুত। এই দুটি কৌশল কার্য সম্পাদনে প্রায় অভিন্ন; আপনি কোনটি পছন্দ করেন তা স্বাদের বিষয়।
System.arraycopy(src, 0, dest, 0, src.length)প্রায় হিসাবে দ্রুত এবং খুব ধারাবাহিকভাবে না। (কেসটি 50000 এর জন্য দেখুন )) এর কারণে এবং কলটির ভারসোসিটির কারণে, আমি আপনাকে পরামর্শ দিচ্ছি যে কোন উপাদানগুলি কোথায় অনুলিপি করা হয়েছে তার উপর যদি আপনার সূক্ষ্ম নিয়ন্ত্রণের প্রয়োজন হয়।Arrays.copyOf(array, array.length)array.clone()intSystem.arraycopy()

সময় প্লট এখানে:

Question 6

নেটিভ পদ্ধতিগুলি কার্যকর করার মতো Arrays.copyOf(T[], int)কিছু ওভারহেড থাকে তবে এর অর্থ এই নয় যে আপনি জেএনআই ব্যবহার করে এটি কার্যকর করছেন বলে এটি দ্রুত নয়।

সবচেয়ে সহজ উপায় হ'ল একটি মানদণ্ড এবং পরীক্ষা লিখুন।

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 (জাভা নেটিভ ইন্টারফেস) ব্যবহার করে, সুতরাং এটি নির্লজ্জভাবে দ্রুত হয়, আপনি এখানে নিশ্চিত করতে পারেন

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()একটি নেটিভ কল যা মেমোরিতে সরাসরি অনুলিপি অপারেশন করে। একক মেমরি অনুলিপি আপনার লুপের চেয়ে সবসময় দ্রুত হবে