මෙම foreachලූපය එකතු, ජාවා 5 (ද "ලූප සඳහා වැඩි දියුණු" ලෙස හැඳින්වෙන), භාවිතා කිරීමට සමාන වේ java.util.Iteratorදෙයක් සඳහා ම --it ගේ සින්ටැක්ටික් සීනි. එමනිසා, එක් එක් මූලද්රව්ය එකින් එක හා පිළිවෙලට කියවන විට foreach, එය වඩාත් පහසු හා සංක්ෂිප්ත බැවින් සෑම විටම අනුකාරකයක් හරහා තෝරා ගත යුතුය.
foreach
for(int i : intList) {
System.out.println("An element in the list: " + i);
}
අනුකාරක
Iterator<Integer> intItr = intList.iterator();
while(intItr.hasNext()) {
System.out.println("An element in the list: " + intItr.next());
}
ඔබ Iteratorකෙලින්ම භාවිතා කළ යුතු අවස්ථා තිබේ . උදාහරණයක් ලෙස, කෑන් foreach(කැමැත්ත?) භාවිතා කරන අතරතුර මූලද්‍රව්‍යයක් මකා දැමීමට උත්සාහ කිරීම a ConcurrentModificationException.
foreachඑදිරිව for: මූලික වෙනස්කම්
අතර ඇති එකම ප්රායෝගික වෙනසක් forහා foreachසුචිමය වස්තූන් පිළිබඳ පැමිණිල්ලේ දී, ඔබ දර්ශකය සඳහා ප්රවේශයන් නොමැත, බව ය. මූලික forපුඩුවක් අවශ්‍ය වූ විට උදාහරණයක් :
for(int i = 0; i < array.length; i++) {
if(i < 5) {
// Do something special
} else {
// Do other stuff
}
}
ඔබට වෙනම දර්ශකයක් int-variable සමඟ අතින් නිර්මාණය කළ හැකි වුවද foreach,
int idx = -1;
for(int i : intArray) {
idx++;
...
}
විචල්ය-විෂය පථය පරිපූර්ණ නොවන බැවින් එය නිර්දේශ නොකරයි, සහ මූලික forලූපය හුදෙක් මෙම භාවිත අවස්ථාව සඳහා සම්මත සහ අපේක්ෂිත ආකෘතියයි.
foreachඑදිරිව for: කාර්ය සාධනය
එකතු ප්රවේශ වූ විට, foreachවේ සැලකිය යුතු වේගයකින් මූලික වඩා forපුඩුවක් ගේ මාලාවක් ප්රවේශය. කෙසේ වෙතත්, අරා වලට ප්රවේශ වන විට - අවම වශයෙන් ප්‍රාථමික හා එතීෙම් අරා සමඟ - දර්ශක හරහා ප්රවේශය නාටකාකාර ලෙස වේගවත් වේ.
ප්‍රාථමික අන්තර් අරා සඳහා අනුකාරක සහ දර්ශක ප්රවේශය අතර වෙනස කාලානුරූපව
දර්ශක ප්රවේශ වන විට හෝ අරා වල යෙදෙන අයට වඩා සියයට 23- 40 අතර වේගවත් වේ . මෙම පෝස්ට් පතුලේ ඇති පරීක්ෂණ පන්තියේ ප්රතිදානය මෙන්න, එය මූලද්රව්ය 100 ක ප්‍රාථමික-අරා අරාවෙහි සංඛ්‍යා සාරාංශ කරයි (A යනු iterator, B යනු දර්ශකය):intInteger
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)
මම මෙය ද Integerඅරාව සඳහා ධාවනය කළ අතර , දර්ශක තවමත් පැහැදිලි ජයග්රාහකයා වන නමුත් වේගයෙන් සියයට 18 ත් 25 ත් අතර ප්‍රමාණයක් පමණි.
එකතු කිරීම සඳහා, අනුකාරක දර්ශකවලට වඩා වේගවත් වේ
සඳහා Listවන Integers, කෙසේ වෙතත්, iterators පැහැදිලි ජයග්රාහකයා වේ. පරීක්ෂණ පන්තියේ int-array වෙනස් කරන්න:
List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100});
පරීක්ෂණ ශ්‍රිතයට අවශ්‍ය වෙනස්කම් කරන්න ( int[]to List<Integer>, lengthto size(), etc.):
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)
එක් පරීක්ෂණයකදී ඒවා බොහෝ දුරට සමාන ය, නමුත් එකතු කිරීම් සමඟ, iterator ජය ගනී.
* මෙම ලිපිය පදනම් වී ඇත්තේ මා විසින් ලියන ලද පිළිතුරු දෙකක් මත ය.
තවත් තොරතුරු: වඩා කාර්යක්ෂම වන්නේ, සෑම ලූපයක් සඳහාම, හෝ ඉරේටරයක්ද?
සම්පූර්ණ පරීක්ෂණ පන්තිය
ස්ටැක් පිටාර ගැලීම පිළිබඳ මෙම ප්රශ්නය කියවීමෙන් පසු මම මෙම සංසන්දනය-කාලය-ගත යුතු-ඕනෑම-දෙයාකාර පන්තියක් නිර්මාණය කළෙමි :
import java.text.NumberFormat;
import java.util.Locale;
/**
<P>{@code java TimeIteratorVsIndexIntArray 1000000}</P>
@see <CODE><A HREF="/programming/180158/how-do-i-time-a-methods-execution-in-java">/programming/180158/how-do-i-time-a-methods-execution-in-java</A></CODE>
**/
public class TimeIteratorVsIndexIntArray {
public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);
public static final void main(String[] tryCount_inParamIdx0) {
int testCount;
// Get try-count from a command-line parameter
try {
testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
}
catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
throw new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
}
//Test proper...START
int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};
long lStart = System.nanoTime();
for(int i = 0; i < testCount; i++) {
testIterator(intArray);
}
long lADuration = outputGetNanoDuration("A", lStart);
lStart = System.nanoTime();
for(int i = 0; i < testCount; i++) {
testFor(intArray);
}
long lBDuration = outputGetNanoDuration("B", lStart);
outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
}
private static final void testIterator(int[] int_array) {
int total = 0;
for(int i = 0; i < int_array.length; i++) {
total += int_array[i];
}
}
private static final void testFor(int[] int_array) {
int total = 0;
for(int i : int_array) {
total += i;
}
}
//Test proper...END
//Timer testing utilities...START
public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
long lDuration = System.nanoTime() - l_nanoStart;
System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
return lDuration;
}
public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
long lDiff = -1;
double dPct = -1.0;
String sFaster = null;
if(l_aDuration > l_bDuration) {
lDiff = l_aDuration - l_bDuration;
dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
sFaster = "B";
}
else {
lDiff = l_bDuration - l_aDuration;
dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
sFaster = "A";
}
System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
return lDiff;
}
//Timer testing utilities...END
}