“B” මුද්‍රණය “#” මුද්‍රණයට වඩා නාටකාකාර ලෙස මන්දගාමී වන්නේ ඇයි?

මම 1000x හි න්‍යාස දෙකක් ජනනය කළෙමි 1000:

පළමු අනුකෘතිය: Oසහ #.
දෙවන අනුකෘතිය: Oසහ B.

පහත කේතය භාවිතා කරමින්, පළමු අනුකෘතිය සම්පූර්ණ කිරීමට තත්පර 8.52 ක් ගතවිය:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("#");
        }
    }

   System.out.println("");
 }

මෙම කේතය සමඟ, දෙවන අනුකෘතිය සම්පූර්ණ කිරීමට තත්පර 259.152 ක් ගතවිය:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("B"); //only line changed
        }
    }

    System.out.println("");
}

නාටකාකාර ලෙස වෙනස් ධාවන වේලාවන් පිටුපස ඇති හේතුව කුමක්ද?

අදහස් යෝජනා කරන පරිදි, පමණක් මුද්රණය System.out.print("#");ගනී 7.8871බැවින්ද, තත්පර System.out.print("B");දෙන still printing....

එය සාමාන්‍යයෙන් ඔවුන් සඳහා ක්‍රියාත්මක වන බව පෙන්වා දුන් අනෙක් අය ලෙස, මම උදාහරණයක් ලෙස Ideone.com අත්හදා බැලුවෙමි , කේත කොටස් දෙකම එකම වේගයකින් ක්‍රියාත්මක වේ.

පරීක්ෂණ කොන්දේසි:

• මම මේ පරීක්ෂණය දිව Netbeans 7.2 එහි කොන්සෝලය බවට නිමවුම් සහිත,
• මම System.nanoTime()මිනුම් සඳහා භාවිතා කළෙමි

පිරිසිදු සමපේක්ෂනය නම්, ඔබ අක්‍ෂර-එතීමට වඩා වචන එතීමට උත්සාහ කරන පර්යන්තයක් භාවිතා කරන Bඅතර එය වචන චරිතයක් ලෙස සලකන නමුත් #වචන නොවන චරිතයක් ලෙස සලකයි . එබැවින් එය රේඛාවක අවසානයට ළඟා වී රේඛාව බිඳීමට ස්ථානයක් සොයන විට, එය #වහාම දැක සතුටින් එහි කැඩී යයි; එනමුත් B, එය තව දුරටත් සෙවිය යුතු අතර, එතීමට වැඩි පෙළක් තිබිය හැකිය (සමහර පර්යන්තවල මිල අධික විය හැකිය, උදා: බැක්ස්පේස් ප්‍රතිදානය කිරීම, පසුව අකුරු ඔතා නැවත ලිවීමට අවකාශයන් ප්‍රතිදානය කිරීම).

නමුත් එය පිරිසිදු සමපේක්ෂනයකි.

මම ජාවා අනුවාදය 1.8 සමඟ එක්ලිප්ස් එදිරිව නෙට්බීන්ස් 8.0.2 හි පරීක්ෂණ සිදු කළෙමි; මම System.nanoTime()මිනුම් සඳහා භාවිතා කළෙමි .

සූර්යග්‍රහණය:

මෙම අවස්ථා දෙකෙහිම මට එකම වේලාවක් ලැබුණි - තත්පර 1.564 ක් පමණ .

නෙට්බීන්ස්:

• "#" භාවිතා කිරීම: තත්පර 1.536
• "බී" භාවිතා කිරීම: තත්පර 44.164

ඉතින්, පෙනෙන ආකාරයට නෙට්බීන්ස් මුද්‍රණයේ සිට කොන්සෝලය දක්වා නරක ක්‍රියාකාරිත්වයක් ඇති බව පෙනේ.

මෙම කේතය මගින් නිරූපණය කරන ලද ගැටළුව වන්නේ නෙට්බීන්ස් හි උපරිම බෆරයේ රේඛා ඔතා තිබීම බව වැඩි පර්යේෂණ වලින් පසුව මට වැටහුණි System.out.println:

for (int i = 0; i < 1000; i++) {
    long t1 = System.nanoTime();
    System.out.print("BBB......BBB"); \\<-contain 1000 "B"
    long t2 = System.nanoTime();
    System.out.println(t2-t1);
    System.out.println("");
}

කාල ප්‍රති results ලය මිලි තත්පර 225 ක් පමණ වන විට කාල ප්‍රති results ල සෑම පස්වන පුනරාවර්තනය හැර සෑම තත්පරයකම මිලි තත්පර 1 ක් අඩු වේ. වැනි දෙයක් (නැනෝ තත්පර වලින්):

BBB...31744
BBB...31744
BBB...31744
BBB...31744
BBB...226365807
BBB...31744
BBB...31744
BBB...31744
BBB...31744
BBB...226365807
.
.
.

සහ යනාදි..

සාරාංශය:

1. සූර්යග්‍රහණය "බී" සමඟ හොඳින් ක්‍රියා කරයි
2. නෙට්බීන්ස් හි රේඛා ඔතා ගැටළුවක් විසඳිය හැකිය (ගැටළුව සූර්යග්‍රහණය තුළ සිදු නොවන නිසා) (බී ("බී") පසු අවකාශය එකතු නොකර).

ඔව් වැරදිකරු අනිවාර්යයෙන්ම වචන ඔතා. මම ඔබේ වැඩසටහන් දෙක පරීක්ෂා කළ විට, NetBeans IDE 8.2 මට පහත ප්‍රති .ලය ලබා දුන්නේය.

1. පළමු අනුකෘතිය: ඕ සහ # = තත්පර 6.03
2. දෙවන අනුකෘතිය : ඕ සහ බී = තත්පර 50.97

ඔබේ කේතය දෙස සමීපව බැලීමෙන් ඔබ පළමු ලූපය අවසානයේ රේඛීය විවේකයක් භාවිතා කර ඇත. නමුත් ඔබ දෙවන ලූපයේ කිසිදු රේඛීය විවේකයක් භාවිතා කළේ නැත. එබැවින් ඔබ දෙවන ලූපයේ අක්ෂර 1000 ක් සහිත වචනයක් මුද්‍රණය කිරීමට යන්නේ ය. එය වචන ඔතා ගැටළුවක් ඇති කරයි. අපි B ට පසුව වචන නොවන අක්ෂරයක් භාවිතා කරන්නේ නම් , වැඩසටහන සම්පාදනය කිරීමට ගත වන්නේ තත්පර 5.35 ක් පමණි . අගයන් 100 ක් හෝ අගයන් 50 ක් පසු කිරීමෙන් පසු අපි දෙවන පුඩුවේ රේඛීය විවේකයක් භාවිතා කරන්නේ නම්, එය ගත වන්නේ පිළිවෙලින් තත්පර 8.56 සහ තත්පර 7.05 ක් පමණි .

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("B");
        }
        if(j%100==0){               //Adding a line break in second loop      
            System.out.println();
        }                    
    }
    System.out.println("");                
}

තවත් උපදෙසක් නම් නෙට්බීන්ස් IDE හි සැකසුම් වෙනස් කිරීමයි. පළමුව, නෙට්බීන්ස් මෙවලම් වෙත ගොස් විකල්ප ක්ලික් කරන්න . ඉන්පසු සංස්කාරකය ක්ලික් කර ආකෘතිකරණ පටිත්ත වෙත යන්න . ඉන්පසු ඕනෑම තැනක දී ලයින් සඟරාව ඔප්ෂන්. වැඩසටහන සම්පාදනය කිරීමට 6.24% කට වඩා අඩු කාලයක් ගතවනු ඇත.