- 1 1. හැඳින්වීම
- 2 2. සම්මත for ලූපය vs වැඩිදියුණු කළ for ලූපය
- 3 3. වැඩිදියුණු කළ for ලූපයේ මූලික ව්යාකරණය සහ භාවිතය
- 4 4. රූප සටහන් සමඟ සැකසුම් ප්රවාහය අවබෝධ කර ගැනීම
- 5 5. ප්රායෝගික නියැදි කේතය
- 6 6. සාමාන්ය for ලූපය වඩා සුදුසු වන අවස්ථා
- 7 7. Java 8 forEach() සමඟ වෙනස්කම්
- 8 8. කාර්ය සාධන සැලකිලි
- 9 9. සාමාන්ය දෝෂ සහ අවධානම්
- 10 10. නිගමනය
- 11 11. නිතර අසන ප්රශ්න
1. හැඳින්වීම
Java ක්රමලේඛනයේදී, ව්යුහාකාර හෝ එකතුවන්ගේ අංග ක්රමානුකූලව සැකසීම අවශ්ය වන තත්ත්වයන් ආරම්භකයින්ට මෙන්ම පළපුරුදු සංවර්ධකයින්ට ද සුලබය. විශේෂයෙන්ම, වැඩිදියුණු කළ for ලූපය (for-each ප්රකාශය) එහි සරලභාවය සහ ඉහළ පාඨකීයතාව නිසා බොහෝ Java සංවර්ධන පරිසරවල සහ ඉගෙනුම් ද්රව්යවල ප්රචලිතය.
සාම්ප්රදායික for ලූපයට සාපේක්ෂව, වැඩිදියුණු කළ for ලූපය පිරිසිදු ව්යාකරණයක් ලබා දෙන අතර සුලබ ලූප-සම්බන්ධ දෝෂ අඩු කිරීමට උපකාරී වේ. කෙසේ වෙතත්, ආරම්භකයින්ට, එය සම්මත for ලූපයෙන් වෙනස් වන්නේ කෙසේද සහ එය භාවිතා කළ යුත්තේ කවදාද යන්න පැහැදිලි නොවිය හැක.
මෙම ලිපියෙහි, අපි වැඩිදියුණු කළ for ලූපය පියවරෙන් පියවර පැහැදිලි කරන්නෙමු, එහි මූලික භාවිතය, සාම්ප්රදායික for ලූපයෙන් වෙනස්කම්, සුලබ දෝෂ සහ වැදගත් සලකා බැලීම් ආවරණය කරමින්. අපි ප්රායෝගික කේත උදාහරණ සහ දෘශ්ය පැහැදිලි කිරීම් ද ඇතුළත් කර ඇති අතර, මෙම මාර්ගෝපදේශය Java ආරම්භකයින්ට මෙන්ම සැබෑ ලෝක ව්යාපෘතිවල Java භාවිතා කරන සංවර්ධකයින්ට ද ගුණදායක වේ.
අවසානය දක්වා කියවන්න සහ වැඩිදියුණු කළ for ලූපය ප්රවේශ කරගන්න.
2. සම්මත for ලූපය vs වැඩිදියුණු කළ for ලූපය
Java හි ලූප සැකසුම් සිදු කිරීමේදී, වඩාත් සුලබව භාවිතා වන ගොඩනැගිලි දෙක වන්නේ සම්මත for ලූපය සහ වැඩිදියුණු කළ for ලූපය (for-each ප්රකාශය) ය. එක් එක්කෙනාට වෙනස් ව්යාකරණය, ලක්ෂණ, වාසි සහ අවාසි ඇත. තත්ත්වය අනුව ගැලපෙන එක තෝරා ගැනීම වැදගත් වේ.
සම්මත for ලූපයේ ලක්ෂණ
සම්මත for ලූපය පහත පරිදි ව්යුහාකාර හෝ ලැයිස්තුවකගේ අංග ක්රමානුකූලව ප්රවේශ වීමට සංඛ්යානාත්මකයක් භාවිතා කරයි.
for (int i = 0; i < array.length; i++) {
// Access the i-th element of the array
System.out.println(array[i]);
}
වාසි
- සංඛ්යානාත්මකයක් භාවිතයෙන් ඕනෑම අංගයකට ප්රවේශ විය හැක
- ප්රතිලෝම පිරිසිදු කිරීම, අංග බැහැර කිරීම සහ විශේෂ ස්ථාන සැකසීම සඳහා සහාය දක්වයි
- ව්යුහාකාර සහ ලැයිස්තු දෙකටම ක්රියා කරයි
අවාසි
- සංඛ්යානාත්මක-සම්බන්ධ දෝෂ (උදාහරණයක් ලෙස off-by-one දෝෂ) වැඩි විය හැක
- කේතය වඩා විස්තරාත්මක වීමට බැඳෙනවා
වැඩිදියුණු කළ for ලූපයේ (for-each) ලක්ෂණ
වැඩිදියුණු කළ for ලූපය ව්යුහාරයක හෝ එකතුවක සියලුම අංග ක්රමානුකූලව සැකසීමට අවශ්ය වන විට ගුණදායක වේ.
for (Type variable : arrayOrCollection) {
// Access each element
System.out.println(variable);
}
වාසි
- සංඛ්යානාත්මක කළමනාකරණයක අවශ්යතාවයක් නැත, එබැවින් සංක්ෂිප්ත කේතයක් ලැබෙනවා
- ඉහළ පාඨකීයතාව
- සංඛ්යානාත්මක-සම්බන්ධ දෝෂ වළක්වයි
අවාසි
- සංඛ්යානාත්මක වටිනාකම් අවශ්ය වන විට භාවිතා කළ නොහැක
- ප්රතිලෝම පිරිසිදු කිරීම හෝ අර්ධීය ලූපිං සඳහා සහාය නොදක්වයි
- පිරිසිදු කිරීමේදී අංග එකතු කිරීම හෝ ඉවත් කිරීම සඳහා ගැලපෙන්නේ නැහැ
සංසන්දන වගුව: සම්මත for ලූපය vs වැඩිදියුණු කළ for ලූපය
| Comparison Item | Standard for Loop | Enhanced for Loop |
|---|---|---|
| Simplicity | △ Somewhat verbose | ◎ Very concise |
| Index access | ◎ Supported | × Not supported |
| Reverse iteration | ◎ Supported | × Not supported |
| Element removal | △ Possible (with care) | × Not allowed (collection exceptions exist) |
| Readability | △ Moderate | ◎ High |
සාරාංශය
ඉහත පරිදි පෙන්වා ඇති විදිහට, සම්මත for ලූපය සහ වැඩිදියුණු කළ for ලූපය අරමුණ අනුව ගැලපෙන ලෙස භාවිතා කළ යුතුය.
3. වැඩිදියුණු කළ for ලූපයේ මූලික ව්යාකරණය සහ භාවිතය
වැඩිදියුණු කළ for ලූපය (for-each ප්රකාශය) Java හි පහසුකම් සහිත විශේෂාංගයකි, එය ව්යුහාකාර හෝ එකතුවක සියලුම අංග ක්රමානුකූලව පහසුවෙන් සැකසීමට ඉඩ සලසයි.
මූලික ව්යාකරණය
වැඩිදියුණු කළ for ලූපයේ ව්යාකරණය ඉතා සරලය.
for (ElementType variableName : arrayOrCollection) {
// Processing for each element
}
උදාහරණය: ව්යුහාරයක සියලුම අංග මුද්රණය කිරීම
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
System.out.println(num);
}
මෙම උදාහරණයේදී, numbers ව්යුහාරයේ එක් එක් අංගය ක්රමානුකූලව num වෙත අරමුණු කර ඇති අතර System.out.println(num); භාවිතයෙන් මුද්රණය කර ඇත. සම්මත for ලූපයට සාපේක්ෂව, මෙම ප්රවේශය සංඛ්යානාත්මක විචල්යයක අවශ්යතාවය ඉවත් කර ගනිමින් බොහෝ සරල කේතයක් ලබා දෙයි.
ලැයිස්තු සමඟ වැඩිදියුණු කළ for ලූපය භාවිතා කිරීම
වැඩිදියුණු කළ for ලූපය ව්යුහාකාර පමණක් නොව ලැයිස්තු සහ සෙට් වැනි එකතු සමඟ ද භාවිතා කළ හැක.
List<String> fruits = Arrays.asList("apple", "banana", "orange");
for (String fruit : fruits) {
System.out.println(fruit);
}
.ඔබ සරලව එකතුවේ අංග වර්ගය නියම කර, සියලු අංග අනුක්රමිකව ප්රවේශ විය හැක.
ප්රධාන කරුණු
- සියලු අංග අනුපිළිවෙලින් සැකසීමට අවශ්ය වන විට සුදුසුයි
- දර්ශක කළමනාකරණය ඉවත් කිරීමෙන් කේත දෝෂ අඩු කරයි
- අරේ සහ බොහෝ එකතු (List, Set, ආදිය) සමඟ ක්රියා කරයි
වැදගත් සටහන්
- වැඩිදියුණු for ලූපය පරිවර්තන අනුක්රමය වෙනස් කිරීම හෝ පසුපසට පරිවර්තනය කිරීම සඳහා සුදුසු නොවේ.
- ඔබට දර්ශක අගයන් අවශ්ය නම් හෝ විශේෂ අංග පමණක් සැකසීමට අවශ්ය නම්, සාමාන්ය for ලූපය භාවිතා කරන්න.
4. රූප සටහන් සමඟ සැකසුම් ප්රවාහය අවබෝධ කර ගැනීම
වැඩිදියුණු for ලූපය ලිවීමට සරල වීම පමණක් නොව, එය අභ්යන්තරයෙන් අංග සැකසීමේ ක්රමය ඔබ දැනගත් පසු තේරුම් ගැනීමට පහසුය.
සැකසුම් ප්රවාහය (අරේ උදාහරණය)
වැඩිදියුණු for ලූපය අංග පහත පියවර වලින් සැකසෙයි:
- පළමු අංගය ලබාගෙන එය විචල්යයට පවරන්න
- එම විචල්යය භාවිතා කර ලූප ශරීරය ක්රියාත්මක කරන්න
- ඊළඟ අංගය ලබාගෙන එය පවරන්න
- සියලු අංග සැකසෙන තුරු නැවත කරන්න
ප්රවාහ රූපය (පෙළ නිරූපණය)
Array or List
[ 10, 20, 30, 40 ]
↓ ↓ ↓ ↓
for (int num : numbers) {
// num = 10 → process
// num = 20 → process
// num = 30 → process
// num = 40 → process
}
එකතු (Collections) එකම ආකාරයෙන් ක්රියා කරයි
List සහ Set එකම සංකල්පය අනුගමනය කරයි. අභ්යන්තරයෙන්, Iterator එක අංග එකින් එක ලබාගනී, නමුත් සංවර්ධකයන්ට එය පැහැදිලිව කළමනාකරණය කිරීම අවශ්ය නොවේ.
ප්රවාහය අවබෝධ කිරීමේ ප්රතිලාභ
- පරිවර්තනයේදී විචල්යයන් කෙසේ පවරා ගනීදැයි පැහැදිලි කරයි
- සාමාන්ය for ලූප වලින් වෙනස්කම් තේරුම් ගැනීමට පහසු කරයි
- වැඩිදියුණු for ලූපය කවදා සුදුසුදැයි තීරණය කිරීමට උපකාරී වේ
5. ප්රායෝගික නියැදි කේතය
වැඩිදියුණු for ලූපය බොහෝ සැබෑ-ලෝක අවස්ථා වල භාවිතා වේ. පහත අරේ, List, සහ Map සඳහා උදාහරණ ඇත.
අරේ උදාහරණය
int[] scores = {90, 75, 82, 68, 99};
for (int score : scores) {
System.out.println("Score: " + score);
}
List උදාහරණය
List<String> cities = Arrays.asList("Tokyo", "Osaka", "Nagoya");
for (String city : cities) {
System.out.println("City: " + city);
}
Map උදාහරණය (entrySet භාවිතා කරමින්)
Map<String, Integer> fruitPrices = new HashMap<>();
fruitPrices.put("Apple", 120);
fruitPrices.put("Banana", 80);
fruitPrices.put("Orange", 100);
for (Map.Entry<String, Integer> entry : fruitPrices.entrySet()) {
System.out.println(entry.getKey() + " price: " + entry.getValue());
}
සාරාංශය
- අරේ, List, සහ Set වල සියලු අංග සැකසීමට හොඳම
- Map වල යතුරු සහ අගයන් දෙකම සැකසීමට
entrySet()භාවිතා කරන්න - කියවීමට පහසුකම වැඩි කරයි සහ boilerplate කේතය අඩු කරයි
6. සාමාන්ය for ලූපය වඩා සුදුසු වන අවස්ථා
වැඩිදියුණු for ලූපය පහසු වුවද, එය සෑම විටම හොඳම තේරීම නොවේ.
1. දර්ශක ප්රවේශය අවශ්ය වන විට
String[] names = {"Sato", "Suzuki", "Takahashi"};
for (int i = 0; i < names.length; i++) {
System.out.println("Name #" + (i + 1) + ": " + names[i]);
}
2. පසුපසට පරිවර්තනය
int[] numbers = {10, 20, 30, 40};
for (int i = numbers.length - 1; i >= 0; i--) {
System.out.println(numbers[i]);
}
3. අංශික සැකසීම හෝ අංග මඟ හැරීම
for (int i = 0; i < numbers.length; i++) {
if (i % 2 == 0) {
System.out.println("Even index: " + numbers[i]);
}
}
4. අංග එකතු කිරීම හෝ ඉවත් කිරීම
වැඩිදියුණු for ලූපයක් අතරතුර එකතුවක් වෙනස් කිරීම රන්ටයිම් දෝෂ ඇති කරයි. ඒ වෙනුවට සාමාන්ය for ලූපයක් හෝ Iterator එකක් භාවිතා කරන්න.
සාරාංශය
සරල සම්පූර්ණ පරිවර්තන සඳහා වැඩිදියුණු for ලූපය භාවිතා කරන්න, සහ නිරවද්ය පාලනය අවශ්ය වන විට සාමාන්ය for ලූපය භාවිතා කරන්න.
7. Java 8 forEach() සමඟ වෙනස්කම්
Java 8 එකතු සඳහා forEach() ක්රමය හඳුන්වා දුන්නා.
List<String> colors = Arrays.asList("red", "blue", "green");
colors.forEach(color -> System.out.println(color));
Map forEach උදාහරණය
Map<String, Integer> ages = new HashMap<>();
ages.put("Yamada", 28);
ages.put("Tanaka", 34);
ages.forEach((name, age) -> System.out.println(name + " is " + age + " years old"));
සසඳුම
| Item | Enhanced for Loop | forEach() |
|---|---|---|
| Java Version | Java 5+ | Java 8+ |
| Break/Continue | Supported | Not supported |
| Readability | High | High (for lambda users) |
8. කාර්ය සාධන සැලකිලි
නවීන Java හි, ලූප් වර්ග අතර කාර්ය සාධන වෙනස්කම් අතිශය සුළු වේ.
සාමාන්ය ප්රවණතා
- සම්මත for ලූප් : අරේ සහ ArrayList සඳහා සාමාන්යයෙන් වේගවත්ම වේ.
- උත්සාහිත for ලූප් : සමාන කාර්ය සාධනයක්.
- forEach() : ලැම්බ්ඩා නිසා සුළු අධික පිරිවැය.
සාරාංශය
කාර්ය සාධනයට වඩා කියවීමට පහසුකම සහ නඩත්තු කිරීමේ හැකියාව මත තේරීම කරන්න.
9. සාමාන්ය දෝෂ සහ අවධානම්
- දර්ශක (Index) ප්රවේශය නොහැක
- පරික්රමණය කරන අතරතුර එකතු කිරීම් (collections) වෙනස් නොකරන්න
- Null එකතු කිරීම් NullPointerException එකක් ඇති කරයි
10. නිගමනය
උත්සාහිත for ලූප් සරල පරික්රමණ සඳහා කියවීමට පහසුකම සහ ආරක්ෂාව වැඩි කරයි. එය සම්මත for ලූප් සහ forEach() සමඟ බුද්ධිමත් ලෙස භාවිතා කරන්න.
11. නිතර අසන ප්රශ්න
ප්ර.1. මට අංග (elements) ඉවත් කළ හැකිද?
ප. නැත. Iterator එකක් හෝ සම්මත for ලූප් එකක් භාවිතා කරන්න.
ප්ර.2. මට පසුපසට පරික්රමණ කළ හැකිද?
ප. නැත. සම්මත for ලූප් එකක් භාවිතා කරන්න.
ප්ර.3. එය අන්තර්ගත (nested) කළ හැකිද?
ප. ඔව්.
ප්ර.4. මට කුමන එක තෝරා ගත යුතුද?
ප. පැහැදිලිත්වය සඳහා උත්සාහිත for, ක්රියාකාරී රීතිය සඳහා forEach, සහ පාලනය සඳහා සම්මත for භාවිතා කරන්න.
