Java වැඩිදියුණු for ලූප් (for-each): උදාහරණ, හොඳම ක්‍රම, සහ පොදු වැරදි සමඟ සම්පූර්ණ මාර්ගෝපදේශය

1 1. හැඳින්වීම
2 2. Enhanced for Loop (for-each Loop) හි දළ විශ්ලේෂණය
3 3. Enhanced for Loop හි මූලික ව්‍යාකරණය සහ භාවිතය
4 4. සාම්ප්‍රදායික for Loop සමඟ සංසන්දනයේ වෙනස්කම්
5 5. වැඩිදියුණු for Loop හි ප්‍රායෝගික භාවිතා ක්ෂේත්‍ර
6 6. වැඩිදියුණු for ලූපය භාවිතා නොකළ යුතු අවවාද සහ අවස්ථා
7 7. පොදු දෝෂ සහ ගැටළු විසඳුම්
8 8. සාරාංශය
9 9. නිතර අසන ප්‍රශ්න (FAQ)
10 10. යොමු සබැඳි සහ සම්බන්ධ ලිපි
- 10.1 නිල ලේඛන සහ ප්‍රයෝජනවත් බාහිර සම්පත්
- 10.2 අතිරේක ඉගෙනුම සඳහා නිර්දේශිත පොත්

1. හැඳින්වීම

Java ඉගෙන ගන්නා විට, ඔබ “enhanced for loop” සහ “for-each loop” වැනි මූලපද සංඛ්‍යාවක් නිතර හමු වේ. සම්ප්‍රදායික for loop හි පුරුදු වී ඇත්නම්, ඔබ “මොකද වෙනස?” හෝ “මොකදන්නේ භාවිතා කළ යුතු?” යනුවෙන් ඇසිය හැක.

මෙම ලිපිය Java හි enhanced for loop (for-each loop) විස්තරාත්මකව පැහැදිලි කරයි—මූලික දේවල් සිට ආරම්භ කරමින් ප්‍රායෝගික යෙදුම්, සම්ප්‍රදායික for loop වලින් වෙනස්කම්, සුලබ දෝෂ, වැදගත් අනතුරු ඇඟවීම් සහ සැබෑ සංවර්ධනයේදී භාවිතා වන ප්‍රශ්න සහ පිළිතුරු දක්වා.
Enhanced for loop යනු arrays සහ collections වැනි බහු දත්ත අංග සමඟ වැඩ කරන විට සරල සහ පාඨකීය කේත ලිවීමට ඉඩ සලසන පහසුකමකි. මෙම මාර්ගෝපදේශය Java ආරම්භකයින්ගෙන් ආරම්භ කරමින් සැබෑ ලෝක ව්‍යාපෘතිවල Java භාවිතා කරන මධ්‍යම සංවර්ධකයින් දක්වා පුළුල් පාඨක පිරිසකට “ඇයි” සහ “කෙසේද” යන ප්‍රශ්නවලට පිළිතුරු ලබා දීමට උපකාරී වේ.

මෙම ලිපිය කියවීමෙන්, ඔබ enhanced for loop භාවිතා කිරීමේ ක්‍රමය පමණක් නොව, එය සහ සම්ප්‍රදායික for loop අතර තේරීම කිරීම, උසස් භාවිතා රටා සමඟ සමඟ පද්ධතිමය අවබෝධයක් වර්ධනය කර ගනිමින්. ඔබේ Java loop සැකසුම් වඩා කාර්යක්ෂම කිරීමට හෝ පාඨකීයභාවය වැඩිදියුණු කිරීමට අපේක්ෂා කරන්නේ නම්, මෙම මාර්ගෝපදේශය විශේෂයෙන් උපකාරී වේ.

2. Enhanced for Loop (for-each Loop) හි දළ විශ්ලේෂණය

Enhanced for loop (for-each loop) යනු Java 5 (JDK 1.5) හි හඳුන්වා දුන් loop ව්‍යාකරණයකි. ඉංග්‍රීසියෙහි, එය “enhanced for statement” හෝ “for-each loop” ලෙස හඳුන්වයි. එහි විශාලතම වාසිය වන්නේ සම්ප්‍රදායික for loop ගණනාවට සාපේක්ෂව වඩා සංක්ෂිප්ත කේත ලිවීමට ඉඩ සැලසීමයි.

මෙම ව්‍යාකරණය ප්‍රධාන වශයෙන් arrays හෝ collections (List හෝ Set වැනි) හි සෑම අංගයක්ම අනුපිළිවෙලින් සැකසීමට අවශ්‍ය වන විට භාවිතා වේ. සම්ප්‍රදායික for loop සමඟ, ඔබ index variable එකක් සූදානම් කළ යුතු වන අතර අංග ගණන සහ සීමාවන් මූලිකව කළමනාකරණය කළ යුතුය, නමුත් enhanced for loop එම අවශ්‍යතාව ඉවත් කරයි.

Enhanced for loop භාවිතා කිරීමෙන් “array එකක සෑම අංගයක්ම ලබා ගැනීම” හෝ “list එකක සෑම වස්තුවක්ම සැකසීම” වැනි මෙහෙයුම් ස්වභාවිකව සහ ආරක්ෂිතව සිදු කළ හැක. එය පාඨකීයභාවය වැඩිදියුණු කරන අතර දෝෂ සම්භාවිතාව අඩු කරයි, එබැවින් එය නූතන Java කේතනයේ සම්මත ශෛලියක් ලෙස බහුලව භාවිතා වේ.

Enhanced for loop හි ප්‍රධාන ලක්ෂණ ඇතුළත් වන්නේ:

Java 5 සහ පසුව ලබා ගත හැක
Arrays සහ collections හි සියලුම අංගවලට පහසු ප්‍රවේශය සපයයි
කේතය කෙටි කරන අතර පාඨකීයභාවය වැඩිදියුණු කරයි
සීමා සම්බන්ධ දෝෂ සහ index දෝෂ වැළැක්වීමට උපකාරී වේ

මෙම හේතු නිසා, බහු අංග අනුපිළිවෙලින් සැකසීමට අවශ්‍ය වන තත්ත්වයන්හි enhanced for loop ඝනව නිර්දේශ කෙරේ.

3. Enhanced for Loop හි මූලික ව්‍යාකරණය සහ භාවිතය

Enhanced for loop (for-each loop) යනු array හෝ collection එකක සියලුම අංග අනුපිළිවෙලින් සැකසීමට අවශ්‍ය වන විට ඉතා පහසුකම් සපයයි. එහි මූලික ව්‍යාකරණය පහත පරිදිය:

for (DataType variable : arrayOrCollection) {
    // Processing for each element
}

උදාහරණය: Arrays සමඟ Enhanced for Loop

උදාහරණයක් ලෙස, int array එකක සියලුම අංග පිටපත් කිරීමට අවශ්‍ය නම්, ඔබ ලියන්නට පුළුවන්:

int[] numbers = {1, 2, 3, 4, 5};

for (int num : numbers) {
    System.out.println(num);
}

මෙම උදාහරණයේදී, numbers array එකක සෑම අංගයක්ම අනුපිළිවෙලින් num වෙත අර්ථනය වන අතර System.out.println(num); එය මුද්‍රණය කරයි. සම්ප්‍රදායික for loop හි සාපේක්ෂව, මෙය index කළමනාකරණයේ අවශ්‍යතාව ඉවත් කරන අතර කේතය බොහෝ සරල කරයි.

උදාහරණය: Lists සහ අනෙකුත් Collections

Enhanced for loop එය List සහ Set වැනි collections සමඟ ද භාවිතා කළ හැක. උදාහරණයක් ලෙස, String list එකක සියලුම අංග මුද්‍රණය කිරීමට:

List<String> names = Arrays.asList("田中", "佐藤", "鈴木");

for (String name : names) {
    System.out.println(name);
}

පෙර උදාහරණයේ මෙන්, names list එකක සෑම අංගයක්ම අනුපිළිවෙලින් name වෙත අර්ථනය වේ. Iterable interface ක්‍රියාත්මක කරන ඕනෑම collection එකක්—List, Set සහ තවත්—enhanced for loop භාවිතා කරමින් සැකසිය හැක.

නියමාව ලෙස පිටපත

හෝ

田中
佐藤
鈴木

වැඩිදියුණු for loop එක සියලුම අංග ක්‍රියාකාරී කිරීමට ඔබට සංකීර්ණ loop සඳහා හෝ index variables ගැන බලපෑම් නොකර සංවාදයේ සියලුම අංග ක්‍රියාකාරී කිරීමට අවශ්‍ය වන විට යෝග්‍ය වේ。

4. සාම්ප්‍රදායික for Loop සමඟ සංසන්දනයේ වෙනස්කම්

Java විසින් loop ව්‍යුහයන්ගේ දෙකක් ලබා දෙයි: “සාම්ප්‍රදායික for loop (index-අඩඋපුටා for loop)” සහ “වැඩිදියුණු for loop (for-each loop).” දෙකම iterative processing සඳහා භාවිතා වුවද, එක් එක්කින් තමන්ගේම ශක්තීන්, දුර්වලතා සහ සුදුසු භාවිතා ක්ෂේත්‍ර ඇත.

Syntax හි වෙනස්කම්

සාම්ප්‍රදායික for Loop (Index-අඩඋපුටා)

for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

මෙම ආකෘතිය array හෝ list එකක එක් එක් අංගයට ප්‍රවේශ වීමට index i භාවිතා කරයි.

index එක ලබා ගත හැකි වීම නිසා, මෙම ප්‍රවේශය random access, partial looping, reverse-order processing සහ වෙනත් නම්‍යශීලී මෙහෙයුම් සඳහා අවකාශය සපයයි.

වැඩිදියුණු for Loop (for-each)

for (DataType element : arrayOrCollection) {
    System.out.println(element);
}

මෙම ආකෘතිය සියලුම අංග එකින් එක variable එකකට ස්වයංක්‍රීයව කේන්ද්‍රණය කර sequential වශයෙන් ක්‍රියාකාරී කරයි.
ඔබට index එක manage කිරීමට අවශ්‍ය නොවේ, code එක වඩාත් සංක්ෂිප්ත කරයි.

සංසන්දන සාරණි: වැඩිදියුණු for Loop vs. සාම්ප්‍රදායික for Loop

Aspect	Enhanced for Loop	Traditional for Loop
Simplicity of Syntax	◎ Very simple and intuitive	△ Slightly complex
Index Manipulation	× Not possible	◎ Fully available
Element Removal	× Not recommended	△ Possible with proper handling
Processing All Elements	◎	◎
Reverse Order Processing	× Not possible	◎ Easily written
Skipping Elements	× Difficult	◎ Flexible control

ඔබ කුමන එක භාවිතා කළ යුතුද? ප්‍රධාන තීරණ ලක්ෂ්‍ය

වැඩිදියුණු for Loop යෝග්‍ය වන විට:

array හෝ collection එකක සියලුම අංග ක්‍රියාකාරී කිරීමට ඔබට අවශ්‍ය
සංක්ෂිප්ත, පාඨකයට පහසු code එකක් ඔබට අවශ්‍ය
index values හෝ reverse processing ඔබට අවශ්‍ය නොවේ

සාම්ප්‍රදායික for Loop යෝග්‍ය වන විට:

index values ඔබට අවශ්‍ය (උදා: නිශ්චිත පිහිටුම්වලට ප්‍රවේශ වීම, reverse-order loops, හෝ නිශ්චිත අංග skip කිරීම)
elements add හෝ remove කිරීමට ඔබට අවශ්‍ය, හෝ iterators භාවිතයෙන් වඩාත් සංකීර්ණ මෙහෙයුම් සිදු කිරීමට

වෙනස්කම් තේරුම් ගැනීම සහ තත්ත්වයට ගැලපෙන loop එක තෝරා ගැනීම Java code එක efficient සහ safe ලෙස ලිවීමට අත්‍යවශ්‍ය වේ.

5. වැඩිදියුණු for Loop හි ප්‍රායෝගික භාවිතා ක්ෂේත්‍ර

වැඩිදියුණු for loop (for-each loop) arrays සහ lists වැනි මූලික ව්‍යුහයන් සමඟ පමණක් නොව විවිධ data types සහ real-world use cases සමඟද භාවිතා කළ හැක. පහත දැක්වෙන්නේ බහුලව හමුවන ප්‍රායෝගික උදාහරණ කිහිපයකි.

Map එකක් හරහා Looping

Map එක key–value pairs ලෙස data store කරයි. වැඩිදියුණු for loop භාවිතා කිරීමේදී, ඔබ සාමාන්‍යයෙන් entrySet() හරහා iterate කරයි.
පහත උදාහරණය Map එකක සියලුම key–value pairs print කරයි:

Map<String, Integer> scores = new HashMap<>();
scores.put("田中", 80);
scores.put("佐藤", 90);
scores.put("鈴木", 75);

for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.println(entry.getKey() + "：" + entry.getValue());
}

entrySet() භාවිතයෙන්, ඔබ එක් එක් entry (key–value pair) එකක් එකින් එක retrieve කර ගනී.

ද්විමාත්‍ර array එකක් හරහා Looping

වැඩිදියුණු for loops multidimensional arrays සමඟද හොඳින් ක්‍රියා කරයි. උදාහරණයක් ලෙස, 2D integer array එකක සියලුම අංග print කිරීම:

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int[] row : matrix) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

බාහිර loop එක එක් එක් row (1D array) retrieve කර ගනී, සහ අභ්‍යන්තර loop එක එම row තුළ අංග print කරයි.

Objects හි Arrays හෝ Lists හරහා Looping

වැඩිදියුණු for loops objects හි arrays හෝ lists සමඟද ක්‍රියා කරයි. උදාහරණයක් ලෙස, array එකක Person objects store කිරීම සහ එක් එක් name print කිරීම:

class Person {
    String name;
    Person(String name) {
        this.name = name;
    }
}

Person[] people = {
    new Person("田中"),
    new Person("佐藤"),
    new Person("鈴木")
};

for (Person person : people) {
    System.out.println(person.name);
}

Sets සහ වෙනත් Collections සමඟ වැඩිදියුණු for Loop භාවිතය

ඔබට Sets සමඟද, ඒවා unique elements ඇතුළත් වන අතර guaranteed order රහිතයි, වැඩිදියුණු for loops භාවිතා කළ හැක.
උදාහරණයක් ලෙස:

Set<String> fruits = new HashSet<>(Arrays.asList("リンゴ", "バナナ", "オレンジ"));

for (String fruit : fruits) {
    System.out.println(fruit);
}

.Enhanced for loops can be used with almost all collections and arrays that Java provides, including collections of objects.

6. වැඩිදියුණු for ලූපය භාවිතා නොකළ යුතු අවවාද සහ අවස්ථා

වැඩිදියුණු for ලූපය ඉතා පහසු වුවද, එය සෑම අවස්ථාවකම හොඳම තේරීම නොවේ. මෙම කොටස වැදගත් අවවාද සහ වැඩිදියුණු for ලූපය නිර්දේශ නොකෙරෙන අවස්ථා පැහැදිලි කරයි.

ඔබට ඉන්ඩෙක්ස් අවශ්‍ය වන විට

වැඩිදියුණු for ලූපයක, ඔබට වත්මන් අංගයේ ඉන්ඩෙක්ස් (ස්ථානය) ලබාගත නොහැක. එබැවින්, ඔබට සමාන-ඉන්ඩෙක්ස් අංග පමණක් සැකසීමට හෝ නියමිත ඉන්ඩෙක්ස් පරාසයන්ට ප්‍රවේශ වීමට අවශ්‍ය වන අවස්ථා වල, සාම්ප්‍රදායික for ලූපය වඩා සුදුසු වේ.

උදාහරණය: සාම්ප්‍රදායික for ලූපයක ඉන්ඩෙක්ස් භාවිතා කිරීම

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    if (i % 2 == 0) {
        System.out.println(numbers[i]);
    }
}

අංග එකතු කිරීම හෝ ඉවත් කිරීමේදී

වැඩිදියුණු for ලූපයක් භාවිතා කරන අතරතුර එකතුකිරීමක් හෝ ඉවත් කිරීමක් කිරීමට උත්සාහ කළහොත්, Java ConcurrentModificationException දෝෂයක් නිකුත් කළ හැක. පරික්‍රමණය අතරතුර එකතුකිරීමේ ප්‍රමාණය වෙනස් කරන විට, Iterator භාවිතා කිරීම නිර්දේශ කරයි.

උදාහරණය: Iterator භාවිතා කර අංග ඉවත් කිරීම

List<String> names = new ArrayList<>(Arrays.asList("田中", "佐藤", "鈴木"));
Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    if (name.equals("佐藤")) {
        iterator.remove();
    }
}

එම ක්‍රියාව වැඩිදියුණු for ලූපයක් තුළ උත්සාහ කිරීම දෝෂයක් ඇති කරයි, එබැවින් අවධානයෙන් ක්‍රියා කළ යුතුය.

null හෝ හිස් අරේස්/එකතුකිරීම් සැකසීම

null අරේයක් හෝ එකතුකිරීමක් මත වැඩිදියුණු for ලූපයක් භාවිතා කිරීම NullPointerException දෝෂයක් ඇති කරයි. සැකසීමට පෙර සෑමවිටම null පරීක්ෂාවක් කරන්න.

උදාහරණය: Null පරීක්ෂාවක් ක්‍රියාත්මක කිරීම

int[] numbers = null;
if (numbers != null) {
    for (int num : numbers) {
        System.out.println(num);
    }
}

පසුපස ක්‍රමයෙන් සැකසීම හෝ කොන්දේසිමය මඟ හැරීම

වැඩිදියුණු for ලූපයන් සෑමවිටම අංගයන් පළමු සිට අවසානය දක්වා අනුක්‍රමිකව සැකසයි. ඔබට පසුපස ක්‍රමයෙන් සැකසීමට හෝ කොන්දේසි මත අංග මඟ හැරීමට අවශ්‍ය නම්, සාම්ප්‍රදායික for ලූපය වඩා සුදුසු වේ.

සාරාංශයෙන්, සියලු අංග අනුක්‍රමිකව සැකසීමේදී වැඩිදියුණු for ලූපය ඉතා බලවත් වේ. එ obstante, ඉන්ඩෙක්ස්-අධාරිත ක්‍රියා, අංග වෙනස්කිරීම්, හෝ සංකීර්ණ ලූප පාලනය අවශ්‍ය වන විට, සාම්ප්‍රදායික for ලූපය හෝ Iterator වැනි වෙනත් ලූප ව්‍යුහ භාවිතා කළ යුතුය.

7. පොදු දෝෂ සහ ගැටළු විසඳුම්

වැඩිදියුණු for ලූපය (for-each ලූපය) සරල සහ ආරක්ෂිත වුවද, වැරදි භාවිතය අනපේක්ෂිත දෝෂ හෝ බග්ස් ඇති කරයි. මෙම කොටස වාස්තුකාලීන සංවර්ධනයේ දක්නට ලැබෙන පොදු දෝෂ සහ ඒවාට විසඳුම් පැහැදිලි කරයි.

NullPointerException

NullPointerException එකක් වැඩිදියුණු for ලූපයක් භාවිතා කර null අරේයක් හෝ null එකතුකිරීමක් සැකසීමට උත්සාහ කරන විට සිදුවේ. මෙය සාමාන්‍යයෙන් දත්ත ව්‍යුහය ආරම්භ කර නොමැති විට සිදුවේ.

උදාහරණය: දෝෂයක් ඇති කරන කේතය

List<String> names = null;
for (String name : names) { // ← NullPointerException
    System.out.println(name);
}

විසඳුම: Null පරීක්ෂාවක් එක් කරන්න

List<String> names = null;
if (names != null) {
    for (String name : names) {
        System.out.println(name);
    }
}

විකල්පයක් ලෙස, භාවිතා කිරීමට පෙර එකතුකිරීම ආරම්භ කළ හැක, එය ආරක්ෂිත වේ.

අංග ඉවත් කිරීමේදී ConcurrentModificationException

වැඩිදියුණු for ලූපයක් අතරතුර එකතුකිරීමක් හෝ ඉවත් කිරීමක් කිරීමට උත්සාහ කළහොත්, Java ConcurrentModificationException දෝෂයක් නිකුත් කරයි. මෙය Java හි අභ්‍යන්තර ආරක්ෂක ක්‍රමවේදයන් නිසා වන අතර, නවකයන්ට සාමාන්‍ය වැරදි වේ.

උදාහරණය: දෝෂයක් ඇති කරන කේතය

List<String> names = new ArrayList<>(Arrays.asList("田中", "佐藤", "鈴木"));
for (String name : names) {
    if (name.equals("佐藤")) {
        names.remove(name); // ← ConcurrentModificationException
    }
}

විසඳුම: Iterator එකක් භාවිතා කරන්න

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    if (name.equals("佐藤")) {
        iterator.remove(); // Safe removal
    }
}

ඇරේ හෝ එකතු කිරීම් වල ප්‍රමාණය වෙනස් කිරීම

උත්තරීතර for ලූපයක් තුළ, Java ලූපය ආරම්භ වීමට පෙර අංග ගණන තීරණය කරයි.
ඒ නිසා, ඔබ ලූපය අතරතුර දත්ත ව්‍යුහයේ ප්‍රමාණය වෙනස් කරන (උදාහරණként අංග එකතු කිරීම හෝ ඉවත් කිරීම) මෙහෙයුම් කිරීමට උත්සාහ කළහොත්, ලූපය අපේක්ෂිත නොවන ලෙස හැසිරෙයි.

විශේෂයෙන්, ඇරේවල ස්ථාවර ප්‍රමාණයක් ඇත, එබැවින් ඒවායේ දිග ලූපය අතරතුර වෙනස් කළ නොහැක.

වර්ග නොගැලපීමේ දෝෂ

උත්තරීතර for ලූපයක් තුළ, ව්‍යවස්ථාව DataType variable : arrayOrCollection ලෙස අවශ්‍ය වේ.
ඇරේ හෝ එකතු කිරීමේ ප්‍රකාරයේ සැබෑ අංග වර්ගය සමඟ ප්‍රකාශිත දත්ත වර්ගය නොගැලපේ නම්, සංග්‍රහණ දෝෂයක් සිදුවේ.

උදාහරණය: වර්ග නොගැලපීමේ දෝෂ

List&lt;Integer&gt; numbers = Arrays.asList(1, 2, 3);
// for (String num : numbers) { ... } // ← Compile error
for (int num : numbers) { // or Integer num : numbers
    System.out.println(num);
}

උත්තරීතර for ලූපය ශක්තිමත් මෙවලමක් වන අතර, මෙම පොදු වැරදි වලට අවධානය යොමු කිරීම ඔබට ආරක්ෂිත, දෝෂ රහිත වැඩසටහන් ලිවීමට උපකාරී වේ.

8. සාරාංශය

උත්තරීතර for ලූපය (for-each ලූපය) Java හි ඇරේ සහ එකතු කිරීම් සරලව හා ආරක්ෂිතව හසුරවීමට පහසු ව්‍යවස්ථාවකි.
සාම්ප්‍රදායික for ලූපය සමඟ සැසඳූ විට, එය කෙටි හා වඩා කියවීමට පහසු කේතයක් නිර්මාණය කරයි, එබැවින් එය බොහෝ අවස්ථාවල පුළුල් ලෙස භාවිතා වේ.

උත්තරීතර for ලූපය විශේෂයෙන්ම ඔබට ඇරේ හෝ එකතු කිරීමේ සියලු අංග ක්‍රමයෙන් සැකසීමට අවශ්‍ය වන විට ප්‍රයෝජනවත් වේ.
ව්‍යවස්ථාව සරල බැවින්, ලූප පරාස හෝ දර්ශක (index) කළමනාකරණය ගැන කනස්සල්ල නොවී, ඔබට පිරිසිදු කේතයක් ලියන්න පුළුවන්.

කෙසේ වෙතත්, ඔබට දර්ශකයක් භාවිතා කිරීමට, අංග වෙනස් කිරීමට, ප්‍රතිවර්තන-අනුක්‍රම සැකසීමට, හෝ විශේෂ අංග මඟ හැරීමට අවශ්‍ය නම්, සාම්ප්‍රදායික for ලූපයක් හෝ Iterator එකක් භාවිතා කිරීම වඩා සුදුසුය.
උත්තරීතර for ලූපයේ ක්‍රියාකාරිත්වය සහ සීමා තේරුම් ගැනීම ඔබට අවස්ථාවට සුදුසු ලූප ක්‍රමය තෝරා ගැනීමට ඉඩ සලසයි.

මෙම ලිපියේ, අපි උත්තරීතර for ලූපයේ මූලික සහ උසස් භාවිතා, සාම්ප්‍රදායික for ලූපයන් සමඟ වෙනස්කම්, වැදගත් අවධානම්, සහ පොදු දෝෂ සඳහා විසඳුම් ආවරණය කළෙමු.
මෙම දැනුම යොදාගෙන, ඔබට වැඩි කාර්යක්ෂම හා ශක්තිමත් Java යෙදුම් ලිවිය හැක.

9. නිතර අසන ප්‍රශ්න (FAQ)

Q1. උත්තරීතර for ලූපයක් භාවිතා කරන විට දර්ශකය ලබා ගැනීමට ක්‍රමයක් තිබේද?

A1. නැත. උත්තරීතර for ලූපය අංග දර්ශකයට ප්‍රවේශය ලබා නොදේ.
ඔබට දර්ශක අගයන් අවශ්‍ය නම්, සාම්ප්‍රදායික for ලූපයක් (උදාහරණként for (int i = 0; i < array.length; i++)) භාවිතා කළ යුතුය හෝ වෙනම ගණකයක් අතින් කළමනාකරණය කළ යුතුය.
කෙසේ වෙතත්, දර්ශක සැකසීම අත්‍යවශ්‍ය වන අවස්ථාවල, සාමාන්‍යයෙන් උත්තරීතර for ලූපය භාවිතා නොකිරීම වඩා හොඳය.

Q2. උත්තරීතර for ලූපයක් තුළ අංග එකතු හෝ ඉවත් කළ හැද?

A2. නැත. උත්තරීතර for ලූපයක් අතරතුර අංග එකතු හෝ ඉවත් කිරීම ConcurrentModificationException එකක් ඇති කරයි.
ලූපය අතරතුර අංග ආරක්ෂිතව ඉවත් කිරීමට අවශ්‍ය නම්, Iterator එකක් භාවිතා කිරීම නිර්දේශිතය.

Q3. උත්තරීතර for ලූපය සමඟ භාවිතා කළ හැකි දත්ත ව්‍යුහයන් කුමනවාද?

A3. උත්තරීතර for ලූපය ඇරේ සහ Iterable අතුරුමුහුණත ක්‍රියාත්මක කරන ඕනෑම එකතු කිරීම (උදාහරණként List සහ Set) සමඟ ක්‍රියා කරයි.
Map එක සෘජුවම ලූපගත කළ නොහැකි වුවද, ඔබට එය entrySet(), keySet(), හෝ values() භාවිතා කර සැකසිය හැක.

Q4. Map සමඟ උත්තරීතර for ලූපය භාවිතා කිරීමේ නිර්දේශිත ක්‍රමය කුමක්ද?

A4. සාමාන්‍යතම ක්‍රමය මෙසේය:

for (Map.Entry<K, V> entry : map.entrySet()) {
    ...
}

මෙය යතුරු (keys) සහ අගයන් (values) දෙකටම පහසුවෙන් ප්‍රවේශය ලබා දේ.
ඔබට යතුරු හෝ අගයන් පමණක් අවශ්‍ය නම්, keySet() හෝ values() මත ලූපයක් කළ හැක.

Q5. උත්තරීතර for ලූපය සාම්ප්‍රදායික for ලූපයට වඩා මන්දගාමීද?

final answer.A5. බොහෝ දිනපතා භාවිතා කරන අවස්ථා වල, දෙක අතර වැදගත් කාර්ය සාධන වෙනසක් නොමැත.
විශාල දත්ත කට්ටල හෝ ඉහළ-අවධි ක්‍රියාකාරකම් සුළු වෙනස්කම් පෙන්විය හැකි වුවද, කියවීමට පහසුකම සහ ආරක්ෂාව සාමාන්‍යයෙන් වාස්තුකරණය කරයි, එමනිසා වැඩිදියුණු for loop එක සාමාන්‍ය තේරීමක් වේ.

Q6. වැඩිදියුණු for loop එකක් අන්තර්ගත කළ හැද?

A6. ඔව්. ඔබට බහුමාන අරේ හෝ අන්තර්ගත එකතු කිරීම් සඳහා අන්තර්ගත වැඩිදියුණු for loop භාවිතා කළ හැක.
බාහිර සහ අභ්‍යන්තර loop දෙකම for‑each ආකෘතිය භාවිතා කළ හැකි බැවින් 2D අරේ වල ක්‍රියාකාරකම් ලිවීමට සරල වේ.

Q7. වැඩිදියුණු for loop එක සහ Iterator එක අතර තේරීම කෙසේ කළ යුතුද?

A7. ඔබට මූලික එකතු කිරීම වෙනස් කිරීමට (උදාහරණයක් ලෙස අංග ඉවත් කිරීම) අවශ්‍ය නම් Iterator එකක් භාවිතා කරන්න.
ඔබට සියලු අංග අනුක්‍රමයෙන් සැකසීමට අවශ්‍ය නම් වැඩිදියුණු for loop එක භාවිතා කරන්න.
එක් එක් ක්‍රමයට භාවිතා අවස්ථාව අනුව තමන්ගේ ශක්තියන් ඇත.

10. යොමු සබැඳි සහ සම්බන්ධ ලිපි

නිල ලේඛන සහ ප්‍රයෝජනවත් බාහිර සම්පත්

Java™ Tutorials (Oracle Official): Enhanced for Statement Oracle හි Java ලේඛනයෙන් ලබා දෙන වැඩිදියුණු for loop පිළිබඳ නිල විස්තරයක්, සින්ටැක්ස් සහ උදාහරණ ඇතුළත්.
Java Platform SE 8 API Specification – java.lang.Iterable වැඩිදියුණු for loop සමඟ භාවිතා කළ හැකි Iterable අතුරුමුහුණත සඳහා නිල ලේඛනය.

අතිරේක ඉගෙනුම සඳහා නිර්දේශිත පොත්

අපි බලාපොරොත්තු වෙමු මෙම ලිපිය ඔබට Java loop ව්‍යුහයන් පිළිබඳ අවබෝධය ගැඹුරු කර ගැනීමට සහ එකතු කිරීම් නිසි ලෙස භාවිතා කිරීමට ප්‍රේරණය කරනු ඇත.