.
- 1 1. හැඳින්වීම: compareTo යනු කුමක්ද?
- 2 2. compareTo හි මූලික ව්යවස්ථාව සහ එහි ආපසු ලබා දෙන අගයෙහි අර්ථය
- 3 3. compareTo භාවිත උදාහරණය
- 4 4. compareTo සහ equals අතර වෙනස
- 5 5. compareTo භාවිතා කර ප්රායෝගික අනුක්රම උදාහරණ
- 6 6. සුලබ දෝෂ සහ අවධානය යොමු කළ යුතු කරුණු
- 7 7. compareTo භාවිතා කරන උසස් තාක්ෂණ
- 8 8. සාරාංශය
1. හැඳින්වීම: compareTo යනු කුමක්ද?
compareTo ක්රමය කුමක්ද?
Java හි compareTo() ක්රමය වස්තු දෙකක “අනුක්රම සම්බන්ධතාව” සසඳා බැලීමට භාවිතා කරන සම්මත ක්රමවේදයක් වේ. උදාහරණයක් ලෙස, එය එක් ස්ට්රින් එකක් තවත් ස්ට්රින් එකකට පෙරද පසුද යන්න තීරණය කරයි — වෙනත් වචනයෙන් කියනවා නම්, එය සම්බන්ධිත අනුක්රමය ඇගයීමට උපකාරී වේ.
මෙම ක්රමය Comparable අතුරුමුහුණත ක්රියාත්මක කරන පන්තීන්හි භාවිතා කළ හැකි අතර, ස්වභාවික අනුක්රමය මත පදනම්ව සසඳයි. උදාහරණයක් ලෙස, String සහ Integer වැනි සම්මත පන්තීන් දැනටමත් Comparable ක්රියාත්මක කර ඇති බැවින්, ඔබට compareTo() සෘජුවම භාවිතා කළ හැක.
Comparable අතුරුමුහුණත සමඟ සම්බන්ධතාවය
compareTo() යනු Comparable<T> අතුරුමුහුණත තුළ නිර්වචනය කරන අබ්ස්ට්රැක්ට් ක්රමයක් වේ. එය පහත පරිදි ප්රකාශිත වේ:
public interface Comparable<T> {
int compareTo(T o);
}
මෙම අතුරුමුහුණත ක්රියාත්මක කිරීමෙන්, ඔබට ඔබේ අභිරුචි පන්තීන්ට අනුක්රමයක් නියම කළ හැක. උදාහරණයක් ලෙස, ඔබට Employee පන්තිය වයස හෝ නාමය අනුව සකස් කිරීමට අවශ්ය නම්, compareTo() අතිරේක කර, අවශ්ය සසඳුම් තර්කය ලිවිය හැක.
Java හි සසඳුම් භූමිකාව
compareTo() අනුක්රම කිරීමේ මෙහෙයුම් වල මූලික භූමිකාවක් ඉටු කරයි. Collections.sort() වැනි, එකතුවක් ඉහළ අනුක්රමයෙන් සකස් කරන ක්රමය, සහ Arrays.sort() වැනි, අරේ එකතුව සකස් කරන ක්රමය, ඇතුළත compareTo() භාවිතා කර අංගයන්ගේ අනුක්රමය තීරණය කරයි.
වෙනත් වචනයෙන් කියනවා නම්, Java හි “අනුක්රම” සම්බන්ධ සියලු දෙය සඳහා compareTo() අත්යවශ්ය වේ. එය ස්ට්රින්, සංඛ්යා, දිනය වැනි විවිධ දත්ත වර්ග සමඟ ක්රියා කරන ලවච්ච සසඳුම් ක්රමයක් ලබා දේ — එය මූලික සංකල්පයක් වන අතර, ඔබට පූර්ණයෙන්ම අධ්යයනය කළ යුතුය.
2. compareTo හි මූලික ව්යවස්ථාව සහ එහි ආපසු ලබා දෙන අගයෙහි අර්ථය
compareTo හි මූලික ව්යවස්ථාව
compareTo() ක්රමය පහත ආකාරයෙන් භාවිතා කරයි:
a.compareTo(b);
මෙහි, a සහ b යනු එකම වර්ගයේ වස්තු වේ. a යනු කැමතිකරු (caller) වන අතර b යනු පරාමිතිය (argument) වේ. මෙම ක්රමය int වර්ගයේ අගයක් ආපසු ලබා දේ, එය වස්තු දෙක අතර අනුක්රම සම්බන්ධතාවය ප්රකාශ කරයි.
ව්යවස්ථාව ඉතා සරල වුවද, ආපසු ලබා දෙන අගයේ අර්ථය නිවැරදිව අවබෝධ කර ගැනීම compareTo() කාර්යක්ෂමව භාවිතා කිරීමේ මූලිකයයි.
ආපසු ලබා දෙන අගයේ අර්ථය නිවැරදිව අවබෝධ කර ගැනීම
compareTo() ආපසු ලබා දෙන අගය පහත සඳහන් තුනෙන් එකක් වේ:
1. 0 (ශූන්ය)
කැමතිකරු වස්තුව සහ පරාමිතිය සමාන වන විට ආපසු ලබා දේ.
"apple".compareTo("apple") // → 0
මෙය අනුක්රමය සම්බන්ධයෙන් දෙකම සම්පූර්ණයෙන්ම එකසේ බව අර්ථ දක්වයි.
2. ඍණ අගයක් (උදා: -1)
කැමතිකරු වස්තුව පරාමිතියට වඩා කුඩා වන විට ආපසු ලබා දේ.
"apple".compareTo("banana") // → negative value (-1, etc.)
මෙම උදාහරණයේ, "apple" යනු "banana" ට පෙර ශබ්දකෝෂ අනුක්රමයෙන් පැමිණෙයි, එබැවින් ඍණ අගයක් ආපසු ලැබේ.
3. ධන අගයක් (උදා: 1)
කැමතිකරු වස්තුව පරාමිතියට වඩා විශාල වන විට ආපසු ලබා දේ.
"banana".compareTo("apple") // → positive value (1, etc.)
මෙය කැමතිකරු පරාමිතියට “පසු” බවට තීරණය කරයි.
සසඳුම් පදනම කුමක්ද?
ස්ට්රින් සඳහා, සසඳුම Unicode අගයන් භාවිතා කරන ශබ්දකෝෂ අනුක්රමය මත පදනම් වේ. මෙය සාමාන්යයෙන් මනුෂ්ය අවබෝධයට ගැලපේ, නමුත් ලොකු-කුඩා අකුරු (uppercase vs. lowercase) වැනි කරුණු ගැන අවධානයෙන් සිටිය යුතුය (විස්තර පසුව).
සංඛ්යා සහ දිනය සඳහා, අනුක්රමය සැබෑ සංඛ්යාත්මක අගය හෝ කාලානුක්රමික අගය මත පදනම් වේ. සියලුම අවස්ථාවල, සසඳුම වර්ගයේ ස්වභාවික අනුක්රමය අනුව සිදු වේ — මෙය compareTo() හි ප්රධාන ලක්ෂණයකි.
compareTo ආපසු ලබා දෙන අගය මත පදනම් වූ තර්ක උදාහරණයක්
උදාහරණයක් ලෙස, if ප්රකාශයක් තුළ compareTo() ආපසු ලබා දෙන අගය මත පදනම්ව තර්කය ශාඛාගත කළ හැක.
String a = "apple";
String b = "banana";
if (a.compareTo(b) < 0) {
System.out.println(a + " is before " + b);
}
ඒ අනුව, compareTo() සසඳුම සඳහා පමණක් නොව, ප්රෝග්රෑම් ප්රවාහය පාලනය කිරීමේ වැදගත් මෙවලමක් ලෙසද භාවිතා කළ හැක.
3. compareTo භාවිත උදාහරණය
compareTo() යනු Java හි විලාස, සංඛ්යා සහ දින වැනි වස්තූන්ගේ සංකෝචනය සංසන්දනය කිරීම සඳහා වඩාත් භාවිතා වන එකකි. මෙම පරිච්ඡේදයේදී, අපි නියෝජිත තත්ත්ව තුනකට අවධානය යොමු කරමු සහ එක් එක් එකකට සැබෑ උදාහරණ සමඟ පැහැදිලි කරමු.
3.1 විලාස සංසන්දනය
Java හි, String වර්ගය Comparable අන්තර්ගතය ක්රියාත්මක කරයි, එබැවින් ඔබට compareTo() භාවිතයෙන් විලාස නිර්මාණශීලී順序යට සංසන්දනය කළ හැක.
මූලික උදාහරණය
String a = "apple";
String b = "banana";
System.out.println(a.compareTo(b)); // Output: negative value
මෙහිදී, "apple" යනු "banana"ට වඩා නිර්මාණශීලී順序යේ පෙර තැනක පවතී, එබැවින් ප්රතිඵලය ලෙස ප්රතිලෝම වටිනාකමක් ලබා දෙයි. Unicode කේත බින්දු මත පදනම් වූ සංසන්දනය නිසා, ස්වභාවික අකුරු අනුපිළිවෙල A → B → C … ඉතා විශ්වාසනීයව පිළිබිඹු වේ.
ලොකු අකුරු සහ කුඩා අකුරු සමඟ සැලකිල්ලෙන්
System.out.println("Apple".compareTo("apple")); // Output: negative value
ලොකු අකුරු සහ කුඩා අකුරුවල විවිධ Unicode වටිනාකම් ඇති නිසා, "Apple" යනු "apple"ට වඩා කුඩා ලෙස සැලකේ. බොහෝ අවස්ථාවලදී, ලොකු අකුරු පළමුව එනවා.
අකුරු වෙනස්කම් නොසලකා හරින්නේ කෙසේද
String පන්තිය compareToIgnoreCase() ක්රමයද ලබා දෙයි.
System.out.println("Apple".compareToIgnoreCase("apple")); // Output: 0
එබැවින්, ඔබ ලොකු සහ කුඩා අකුරු අතර වෙනස සලකන්නේ නැත්නම්, compareToIgnoreCase() භාවිතා කිරීම හොඳ තේරීමකි.
3.2 සංඛ්යා සංසන්දනය (Wrapper Classes)
මූලික වර්ග (int, double ආදිය) වල compareTo() නොමැත, නමුත් wrapper පන්ති (Integer, Double, Long ආදිය) ඔක්කොම Comparable ක්රියාත්මක කරයි.
Integer සංසන්දන උදාහරණය
Integer x = 10;
Integer y = 20;
System.out.println(x.compareTo(y)); // Output: -1
10 යනු 20ට වඩා කුඩා නිසා, ප්රතිලෝම වටිනාකමක් ලබා දෙයි. x = 30 නම්, ප්රතිඵල වටිනාකම ධනාත්මක වේ.
Wrapper වර්ග භාවිතා කිරීමට හේතුව කුමක්ද?
මූලික වර්ග operator වලින් (<, >, ==) සංසන්දනය කළ හැකි වුවද, වස්තූන් සංසන්දනය කිරීමේදී — උදාහරණයක් ලෙස, එකතුවල තුළ වර්ගීකරණය සඳහා — compareTo() අත්යවශ්ය වේ.
3.3 දින සංසන්දනය
LocalDate සහ LocalDateTime වැනි දින/කාල පන්ති Comparable ක්රියාත්මක කරයි, එබැවින් compareTo() භාවිතයෙන් දිනයක් පෙරදී හෝ පසුදාහක් දැනගැනීම පහසුය.
LocalDate සංසන්දන උදාහරණය
LocalDate today = LocalDate.now();
LocalDate future = LocalDate.of(2030, 1, 1);
System.out.println(today.compareTo(future)); // Output: negative value
මෙම උදාහරණයේදී, today යනු futureට වඩා පෙර තැනක පවතී, එබැවින් ප්රතිලෝම වටිනාකමක් ලබා දෙයි. compareTo() භාවිතයෙන් දින සංසන්දනය සංකේතාත්මකව තේරුම් ගැනීම පහසුය.
ප්රායෝගික භාවිතයන්
*ically (e.g., customer list)
* ලකුණු ඉහළ සිට පහළට හෝ පහළ සිට ඉහළට වර්ගීකරණය
* කාලානුකූල අනුපිළිවෙල පරීක්ෂා කිරීම (e.g., බැඳුම්කර දිනය වර්තමාන දිනය සමඟ සංසන්දනය)
compareTo() යනු අත්යවශ්ය මූලික මෙවලමක් වන අතර, එය සැබෑ-ලෝක සංවර්ධනයේදී නිතර පෙන්වයි.
4. compareTo සහ equals අතර වෙනස
Java හි, compareTo() සහ equals() යන දෙකම විවිධ අරමුණු සහ හැසිරීම් ඇත. ප්රතිඵල වටිනාකම් වෙනස් වන බැවින්, ඒවා එකිනෙකට ව්යාජ නොකිරීම වැදගත්.
අරමුණුහි වෙනස
equals() හි අරමුණ: සමානකම පරීක්ෂා කිරීම
equals() ක්රමය භාවිතා වන්නේ දෙකම වස්තූන්ට එකම අන්තර්ගතය ඇතිද යන්න පරීක්ෂා කිරීමට. එහි ප්රතිඵල වටිනාකම boolean — true හෝ false.
String a = "apple";
String b = "apple";
System.out.println(a.equals(b)); // Output: true
එක් එක් විලාස දෙකම එකම පාඨය අඩංගු නම්, true ලබා දෙයි.
compareTo() හි අරමුණ: සංකෝචනය සංසන්දනය
මറු පැත්තේදී, compareTo() ක්රමය වස්තූන් සංසන්දනය කරයි. එය පහත තේරුම සහිත int එකක් ලබා දෙයි:
0සමාන- ප්රතිලෝම වටිනාකම: කෝලර් කුඩා
- ධනාත්මක වටිනාකම: කෝලර් විශාල
System.out.println("apple".compareTo("apple")); // Output: 0 System.out.println("apple".compareTo("banana")); // Output: negative value
ප්රතිඵල වර්ගය සහ තේරුම
| Method Name | Return Type | Meaning |
|---|---|---|
equals() | boolean | Returns true if the content is equal |
compareTo() | int | Returns ordering result (0, positive, negative) |
අනිවාර්යයෙන්ම:
. equals() භාවිතා කරන්න ඔබට සමානත්වය තීරණය කිරීමට අවශ්ය නම්.
compareTo() භාවිතා කරන්න ඔබට අනුක්රමය ඇගයීමට අවශ්ය නම්.
මෙම වෙන් කිරීම නිර්දේශිතය.
ක්රියාත්මක කිරීමේ සටහන: ඒවා එකසැම විය යුතුද?
ජාවාහි හොඳම පුරුදු ක්රමයන් පහත පරිදි සඳහන් කරයි:
“
compareTo()0ක් ලබා දුන්නේ නම්,equals()ද true එකක් ලබා දිය යුතුය.”
මෙය විශේෂයෙන්ම අභිරුචි පන්තියක Comparable ක්රියාත්මක කරන විට වැදගත් වේ. ඒවා අසමතුලිත නම්, අනුක්රම කිරීම සහ සෙවීමේ ක්රියාකාරකම් වැරදි ලෙස ක්රියා කර, දෝෂ උත්පාදනය කරයි.
උදාහරණය: නරක උදාහරණය (equals සහ compareTo අසමතුලිත වේ)
class Item implements Comparable<Item> {
String name;
public boolean equals(Object o) {
// If comparing more than just name, inconsistency may occur
}
public int compareTo(Item other) {
return this.name.compareTo(other.name); // compares only name
}
}
සසඳුම් මාර්ගෝපදේශ වෙනස් නම්, Set හෝ TreeSet තුළේ හැසිරීම අසමත් විය හැක.
ඔබ equals හෝ compareTo භාවිතා කර සසඳා යුතුද?
| Use Case | Recommended Method |
|---|---|
| Checking object equality | equals() |
| Comparisons for sorting / ordering | compareTo() |
| Safe comparison along with null checks | Objects.equals() or Comparator |
null සමඟ compareTo() භාවිතා කිරීම NullPointerException එකක් ඇති කරයි, එසේම equals() සාමාන්යයෙන් එම අංශයේ වඩා ආරක්ෂිත ලෙස ක්රියා කරයි—ඒ නිසා ඔබේ අරමුණ සහ පරිසරය අනුව තෝරන්න.
මෙම පරිච්ඡේදයේ, අපි compareTo() සහ equals() අතර වෙනස්කම් සාරාංශ කර ඇත සහ ඒවා කවදා භාවිතා කළ යුතුද යන්න පැහැදිළි කර ඇත. දෙකම ජාවාහි වැදගත් සසඳුම් ක්රමවේදයන් වන අතර, දෝෂ රහිත කේතයක් ලැබීමට පළමු පියවර වන්නේ “අනුක්රමය” සහ “සමානත්වය” පැහැදිලිව වෙන් කිරීමයි.
5. compareTo භාවිතා කර ප්රායෝගික අනුක්රම උදාහරණ
compareTo() සඳහා සාමාන්යතම භාවිතය අනුක්රම කිරීම වේ. ජාවා අරේ සහ ලැයිස්තු අනුක්රම කිරීමට ප්රයෝජනවත් API ලබා දේ, ඒවා අභ්යන්තරයෙන් compareTo() මත පදනම් වේ.
5.1 ස්ට්රින්ග් අරේ අනුක්රම කිරීම
Arrays.sort() භාවිතා කර, ඔබට String අරේ එකක් ශබ්දකෝෂ ක්රමයෙන් පහසුවෙන් අනුක්රම කළ හැක. String Comparable ක්රියාත්මක කරන බැවින් අමතර සැකසුම් අවශ්ය නොවේ.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
String[] fruits = {"banana", "apple", "grape"};
Arrays.sort(fruits); // Sorted based on compareTo()
System.out.println(Arrays.toString(fruits)); // [apple, banana, grape]
}
}
අභ්යන්තරයෙන්, "banana".compareTo("apple") වැනි සසඳුම් සිදු කර නිවැරදි අනුක්රමය තීරණය කරයි.
5.2 සංඛ්යා ලැයිස්තුව අනුක්රම කිරීම
Integer වැනි රැප්පර් පන්තීන්ද Comparable ක්රියාත්මක කරන බැවින්, Collections.sort() ඒවා සෘජුවම අනුක්රම කළ හැක.
import java.util.*;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(5, 1, 9, 3);
Collections.sort(numbers); // Ascending sort
System.out.println(numbers); // [1, 3, 5, 9]
}
}
අනුක්රම කිරීමේදී, 5.compareTo(1) වැනි සසඳුම් අභ්යන්තරයෙන් ක්රියාත්මක වේ.
5.3 අභිරුචි පන්තියක් අනුක්රම කිරීම: Comparable ක්රියාත්මක කිරීම
ඔබ අභිරුචි පන්තියක Comparable ක්රියාත්මක කරන්නේ නම්, compareTo() භාවිතා කර පරිශීලක‑නිර්මාණ වස්තු අනුක්රම කළ හැක.
උදාහරණය: නාමය අනුව අනුක්රම වන User පන්තිය
public class User implements Comparable<User> {
String name;
public User(String name) {
this.name = name;
}
@Override
public int compareTo(User other) {
return this.name.compareTo(other.name);
}
@Override
public String toString() {
return name;
}
}
මෙම පන්තිය භාවිතා කර ලැයිස්තුවක් අනුක්රම කරමු:
import java.util.*;
public class Main {
public static void main(String[] args) {
List<User> users = Arrays.asList(
new User("Yamada"),
new User("Tanaka"),
new User("Abe")
);
Collections.sort(users); // Sorted by name in ascending order
System.out.println(users); // [Abe, Tanaka, Yamada]
}
}
මෙම උදාහරණයේ, compareTo() name ක්ෂේත්රයේ ස්ට්රින්ග් අගයන් සසඳයි.
5.4 Comparable සහ Comparator අතර වෙනස්කම්
compareTo() ක්ලාසය තුළම ගැනුම්කරුවාගේ ස්වභාවික අනුපිළිවෙල නිර්වචනය කරයි, එතරම් Comparator ක්ලාසයෙන් පිටත, භාවිතා ස්ථානයේදී සංසන්දන තර්කය නිර්වචනය කරයි.
උදාහරණයක් ලෙස, වයසට අනුව වර්ගීකරණය කිරීමට, ඔබට Comparator භාවිතා කළ හැක:
import java.util.*;
class Person {
String name;
int age;
Person(String name, int age) { this.name = name; this.age = age; }
@Override
public String toString() {
return name + " (" + age + ")";
}
}
public class Main {
public static void main(String[] args) {
List<Person> people = Arrays.asList(
new Person("Sato", 30),
new Person("Kato", 25),
new Person("Ito", 35)
);
people.sort(Comparator.comparingInt(p -> p.age)); // Sort by age ascending
System.out.println(people); // [Kato (25), Sato (30), Ito (35)]
}
}
ප්රධාන වෙනස්කම්:
| Comparison Method | Defined Where? | Flexibility | Multiple Sorting Criteria |
|---|---|---|---|
compareTo() | Inside the class (fixed) | Low | Difficult |
Comparator | Specified at sort time | High | Supported |
සාරාංශය
compareTo()Java හි සම්මත වර්ගීකරණයේ පදනම ලෙස විශාල වශයෙන් භාවිතා වේ.Arrays.sort()සහCollections.sort()ඒවා තුළcompareTo()මත රඳා පවතී.Comparableක්රියාත්මක කිරීමෙන්, අභිරුචි ක්ලාස්වලට ස්වභාවික අනුපිළිවෙලක් තිබිය හැක.Comparatorභාවිතා කිරීමෙන් නම්, නම්යශීලී විකල්ප වර්ගීකරණ නීති සක්රිය කළ හැක.
6. සුලබ දෝෂ සහ අවධානය යොමු කළ යුතු කරුණු
compareTo() බලවත් සහ පහසුවෙන් භාවිතා කළ හැකි වුවද, එය වැරදි ලෙස භාවිතා කිරීමෙන් අනපේක්ෂිත හැසිරීම් හෝ දෝෂ ඇති විය හැක. මෙම පරිච්ඡේදයේ, සංවර්ධකයින්經常 ගැටලු වන සුලබ ගැටලු සහ ඒවාට එරෙහිව ගත හැකි පියවර සාරාංශගත කර ඇත.
6.1 NullPointerException ඇති වීම
compareTo() ප්රාර්ථකයා හෝ තර්කය null වන විට NullPointerException විසින් විසි කරයි. මෙය ඉතා සුලබ දෝෂයකි.
උදාහරණය: දෝෂයක් විසි කරන කේතය
String a = null;
String b = "banana";
System.out.println(a.compareTo(b)); // NullPointerException
එරෙහි පියවර: null සඳහා පරීක්ෂා කිරීම
if (a != null && b != null) {
System.out.println(a.compareTo(b));
} else {
System.out.println("One of them is null");
}
එසේම, ඔබට Comparator සමඟ nullsFirst() හෝ nullsLast() භාවිතා කර සුරක්ෂිතව වර්ගීකරණය කළ හැක.
people.sort(Comparator.nullsLast(Comparator.comparing(p -> p.name)));
6.2 ClassCastException හි අවදානම
compareTo() විවිධ වර්ගවල ගැනුම්කරුවන් සංසන්දනය කිරීමේදී ClassCastException විසි කළ හැක. මෙය සාමාන්යයෙන් අභිරුචි ක්ලාස්වල Comparable ක්රියාත්මක කිරීමේදී සිදු වේ.
උදාහරණය: විවිධ වර්ග සංසන්දනය
Object a = "apple";
Object b = 123; // Integer
System.out.println(((String) a).compareTo((String) b)); // ClassCastException
එරෙහි පියවර: වර්ග ස්ථිරභාවය පවත්වා ගන්න
- වර්ග-නිරাপද වන කේතය ලියන්න.
- අභිරුචි ක්ලාස්වලදී generics නිවැරදි ලෙස භාවිතා කරන්න.
- මිශ්ර වර්ග අඩංගු නොවන ලෙස එකතුවන් නිර්මාණය කරන්න.
6.3 equals() සමඟ නොගැලපීම
පෙර සාකච්ඡා කළ පරිදි, compareTo() සහ equals() විවිධ සංසන්දන මිනුම් භාවිතා කරන්නේ නම්, TreeSet සහ TreeMap අනපේක්ෂිතව හැසිරිය හැක — අනපේක්ෂිත බෙදුම් හෝ දත්ත නැති වීම ඇති කරමින්.
උදාහරණය: compareTo 0 ආපසු එවන නමුත් equals false ආපසු එවයි
class Item implements Comparable<Item> {
String name;
public int compareTo(Item other) {
return this.name.compareTo(other.name);
}
@Override
public boolean equals(Object o) {
// If id is included in the comparison, inconsistency can occur
}
}
එරෙහි පියවර:
compareTo()සහequals()මිනුම් තරමක් හැකිනම් ගලපන්න.- අරමුණ (වර්ගීකරණය vs සෙට් අනන්යතාව) අනුව, ඒවා වෙන් කිරීමට
Comparatorභාවිතා කිරීම සලකා බලන්න.
6.4 ශබ්දකෝෂ අනුපිළිවෙල ගැන වැරදි අවබෝධය
compareTo() Unicode වටි මත පදනම්ව වචන සංසන්දනය කරයි. මෙය නිසා, උඩුබඩුඟු සහ පහළබඩුඟු අනුපිළිවෙල මිනිස් සිතියමට වඩා වෙනස් විය හැක.
උදාහරණය:
System.out.println("Zebra".compareTo("apple")); // Negative (Z is smaller than a)
එරෙහි පියවර:
- අකුරු විශාල/කුඩා වෙනස නොසලකා හරිනවා නම් —
compareToIgnoreCase()භාවිතා කරන්න. - අවශ්ය නම්, ප්රදේශ-අදාල (locale‑aware) සැසඳීම සඳහා
Collatorගැන සිතන්න.Collator collator = Collator.getInstance(Locale.JAPAN); System.out.println(collator.compare("あ", "い")); // ස්වභාවික gojūon‑ශෛලී අනුක්රමය
6.5 අසමමාත්යතාව / ප්රතිබිම්බතාව / පාරාක්රමිකත්ව නීති උල්ලංඝනය කිරීම
compareTo() සතුව නීති තුනක් ඇත. ඒවා උල්ලංඝනය කිරීමෙන් අස්ථිර වර්ගීකරණයක් සිදුවේ.
| Property | Meaning |
|---|---|
| Reflexivity | x.compareTo(x) == 0 |
| Symmetry | x.compareTo(y) == -y.compareTo(x) |
| Transitivity | If x > y and y > z, then x > z |
ප්රතිකාර:
- මෙම නීති මත පදනම්ව සැසඳීමේ තර්කය සැලසුම් කිරීම සෑම විටම කරන්න.
- සැසඳීමේ තර්කය සංකීර්ණ වුවහොත්,
Comparatorභාවිතා කරමින් එය පැහැදිලිව ලිවීම වඩා ආරක්ෂිතයි.
සාරාංශය
compareTo()ශක්තිමත් වේ, නමුත් null සහ වර්ග අසමතුලිතතා (type mismatch) විකෘතිකාරක ගැන අවධානයෙන් සිටින්න.equals()සමඟ අනුකූලතාව නොසලකා හරිනුමෙන් දත්ත පිටපත් කිරීම හෝ අහිමි වීම සිදු විය හැක.- අක්ෂර මාලා සැසඳීම Unicode මත පදනම්ව ඇති — එබැවින් අකුරු විශාල/කුඩා වෙනස සහ භාෂා‑විශේෂිත අනුක්රමය ගැන සැලකිල්ලක් තිබිය යුතුය.
- සැසඳීමේ තර්කයේ ස්ථාවරත්වය සෑම විටම සහතික කරන්න — විශේෂයෙන් පාරාක්රමිකත්වය සහ අසමමාත්යතාව.
7. compareTo භාවිතා කරන උසස් තාක්ෂණ
compareTo() ක්රමය මූලික සැසඳීම් වලට සීමා නොවේ. ටිකක් නිර්මාණශීලීත්වයක් සමඟ, සංකීර්ණ වර්ගීකරණය සහ ලවච්චි සැසඳීමේ තර්කය ක්රියාත්මක කළ හැක. මෙම අධ್ಯಾಯය වාස්තුකාලීන සංවර්ධනයේ ප්රයෝජනවත් ත්රි‑ප්රායෝගික තාක්ෂණ තුනක් හඳුන්වා දෙයි.
7.1 බහු‑කොන්දේසි සමඟ සැසඳීම
බොහෝ වාස්තුකාලීන අවස්ථා වල, වර්ගීකරණය බහු කොන්දේසි සලකා බැලිය යුතුය, උදාහරණයක් ලෙස “පළමුව නාමය අනුව වර්ගීකරණය කර, නාමය සමාන නම් වයස අනුව වර්ගීකරණය කරන්න”.
උදාහරණය: නාමය අනුව සැසඳීම → පසුව වයස අනුව
public class Person implements Comparable<Person> {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person other) {
int nameCmp = this.name.compareTo(other.name);
if (nameCmp != 0) {
return nameCmp;
}
// If names are equal, compare age
return Integer.compare(this.age, other.age);
}
@Override
public String toString() {
return name + " (" + age + ")";
}
}
බහු compareTo() හෝ compare() ක්රියාකාරකම් එකතු කිරීමෙන්, සැසඳීමේ ප්රමුඛතාව පාලනය කළ හැක.
7.2 Comparator භාවිතා කරමින් අභිරුචි සැසඳීම
compareTo() එකම “ස්වභාවික අනුක්රමය” නියම කරයි. නමුත් Comparator සමඟ, ඔබට අවස්ථා අනුව වර්ගීකරණ නීති මාරු කළ හැක.
උදාහරණය: වයස අනුව අඩු වීමේ අනුක්රමය
List<Person> list = ...;
list.sort(Comparator.comparingInt((Person p) -> p.age).reversed());
Comparator + lambda භාවිතා කිරීමෙන් ප්රකාශකතාවය සහ සරලතාවය විශාල ලෙස වැඩිවේ, සහ නවීන Java හි පුළුල් ලෙස භාවිතා වේ.
ප්රතිලාභ
- භාවිතා අවස්ථාව අනුව සැසඳීමේ මාර්ගෝපදේශයන් මාරු කළ හැක
- ක්රම‑චේන් කිරීම (method chaining) මගින් බහු කොන්දේසි ප්රකාශ කළ හැක
- ස්වභාවික අනුක්රමය වෙනස් නොකර අතිරේක සැසඳීමේ තර්කය සක්රිය කළ හැක
7.3 Lambda සහ ක්රම යොමු (Method References) භාවිතය
Java 8 සිට, lambda සහ ක්රම යොමු Comparator සමඟ භාවිතා කළ හැකි අතර, කේතය තවත් සංකුචිත කරයි.
උදාහරණය: නාමය අනුව වර්ගීකරණය
list.sort(Comparator.comparing(Person::getName));
බහු කොන්දේසිද චේන් කළ හැක
list.sort(Comparator
.comparing(Person::getName)
.thenComparingInt(Person::getAge));
මෙය සැසඳීමේ නීති චේන්‑සම, කියවීමට පහසු ශෛලියක ප්රකාශ කිරීමට ඉඩ සලසයි, නඩත්තු කිරීම සහ විස්තාරණය වැඩිදියුණු කරයි.
උසස් තාක්ෂණ සාරාංශය
| Technique | Usage / Benefits |
|---|---|
| Implementing compareTo with multiple conditions | Allows flexible definition of natural ordering. Enables complex sorts. |
| Custom sort using Comparator | Can change comparison rules depending on the situation. |
| Lambdas / method references | Concise syntax, highly readable. Standard method in Java 8 and later. |
ප්රායෝගික භාවිතා අවස්ථා
- “දෙපාර්තමේන්තුව → තනතුර → නාමය” අනුව සේවක ලැයිස්තුව පෙන්වන්න
- “දිනය → මුදල → පාරිභෝගික නාමය” අනුව ගනුදෙනු ඉතිහාසය වර්ගීකරණය කරන්න
- “මිල (ආරෝහණ) → තොග (අවරෝහණ)” අනුව නිෂ්පාදන ලැයිස්තුව වර්ගීකරණය කරන්න
මෙවැනි අවස්ථා වල, compareTo() සහ Comparator වර්ගීකරණ තර්කය පැහැදිලිව හා සංකුචිතව ප්රකාශ කිරීමට මාර්ගයක් සපයයි.
8. සාරාංශය
ජාවා compareTo() ක්රමය වස්තුවල සැකසුම සහ ප්රමාණය සංසන්දනය කිරීම සඳහා මූලික සහ අත්යවශ්ය යාන්ත්රණයක් යි. මෙම ලිපියේදී, compareTo() හි භූමිකාව, භාවිතය, අනතුරු ඇඟවීම් සහ උසස් තාක්ෂණයන් ව්යුහගත ආකාරයකින් පැහැදිලි කර ඇත.
මූලික දේවල් පිළිබඳ සමාලෝචනය
compareTo()භාවිතා කළ හැකි වන්නේ ක්ලාස් එකක්Comparableක්රියාත්මක කරන විටයි.- සැකසුම සංඛ්යාත්මකව 0, ධනාත්මක වටිනාකම, ඍණාත්මක වටිනාකම ඔස්සේ ප්රකාශ වේ.
String,Integer, සහLocalDateවැනි බොහෝ සම්මත ජාවා ක්ලාස් එය දැනටමත් සහාය දක්වයි.
අනෙකුත් සංසන්දන ක්රමවලට සාපේක්ෂව වෙනස්කම් සහ භාවිතය
equals()වලට සාපේක්ෂව වෙනස සමඟ පරිදි — සමානභාවය සහ සැකසුම මිශ්ර කරන්න එපා.compareTo()0 ආපසු දෙන විට,equals()සාමාන්යයෙන් true ආපසු දිය යුතුයි — මෙම ස්ථිරභාවයේ නීතිය වැදගත්.
සැබෑ සංවර්ධනයේදී ප්රායෝගික වටිනාකම
compareTo()Arrays.sort()සහCollections.sort()වැනි වර්ගීකරණ මෙහෙයුම්වල මධ්යගත භූමිකාවක් ඉටු කරයි.- අභිරුචි ක්ලාස්වල නම්යශීලී සංසන්දනය සඳහා,
Comparable,Comparator, සහ lambda ඒකාබද්ධ කිරීම ඉතා ඵලදායීය. - null-සම්බන්ධකරණය, අක්ෂර කේත සම්බන්ධකරණය සහ මිනුම් ස්ථිරභාවය සමඟ පරිදි, ඔබට ශක්තිමත් සහ දෝෂ අඩු සංසන්දන තර්කයක් ලිවිය හැකියි.
අවසාන වචන
compareTo() ජාවාවේ සංසන්දනය, වර්ගීකරණය සහ සෙවීම හි මූලික පදනමේ කොටසකි. ක්රමය තමයි සරල ලෙස පෙනුණත්, එහි පදනම් වන නිර්මාණශීලී මූලධර්ම සහ තර්කානුකූල සංසන්දන නීති අවබෝධයෙන් තොරවීම අනපේක්ෂිත අභියෝගවලට තුඩු දෙයි.
මූලික දේවල් ප්රවේශම් කර ගෙන උසස් තාක්ෂණයන් නිදහසේ භාවිතා කළ හැකි වීමෙන්, ඔබට වඩා නම්යශී සහ කාර්යක්ෂම ජාවා වැඩසටහන් ලිවිය හැකියි.
