Comparable vs Comparator in Java
ะะปััะพะฒะฐ ััะทะฝะธัั ะผัะถ Comparable ั Comparator ะฒ Java
- ะะพััะฒะฝัะฝะธะน ะฒ Java โ ัะต ะพะฑโัะบั ะดะปั ะฟะพััะฒะฝัะฝะฝั ะท ัะฝัะธะผ ะพะฑโัะบัะพะผ, ัะพะดั ัะบ Comparator โ ัะต ะพะฑโัะบั ะดะปั ะฟะพััะฒะฝัะฝะฝั ััะทะฝะธั ะพะฑโัะบััะฒ ััะทะฝะธั ะบะปะฐััะฒ.
- Comparable ะทะฐะฑะตะทะฟะตััั
compareTo()ะผะตัะพะด ัะพัััะฒะฐะฝะฝั ะตะปะตะผะตะฝััะฒ Java, ัะพะดั ัะบ Comparator ะฝะฐะดะฐัcompare()ะผะตัะพะด ัะพัััะฒะฐะฝะฝั ะตะปะตะผะตะฝััะฒ Java. - ะะพะดัะฑะฝะธะน ัะฝัะตััะตะนั ะฟัะธัััะฝัะน ั
java.langะฟะฐะบะตั, ัะพะดั ัะบ ัะฝัะตััะตะนั Comparator ะฟัะธัััะฝัะน ัjava.utilะฟะฐะบะตั. - Comparable ะทะฐะฑะตะทะฟะตััั ะพะดะฝั ะฟะพัะปัะดะพะฒะฝัััั ัะพัััะฒะฐะฝะฝั, ะฐ Comparator โ ะบัะปัะบะฐ ะฟะพัะปัะดะพะฒะฝะพััะตะน ัะพัััะฒะฐะฝะฝั.
- Comparable ะฒะฟะปะธะฒะฐั ะฝะฐ ะฟะพัะฐัะบะพะฒะธะน ะบะปะฐั, ัะพะดั ัะบ Comparator ะฝะต ะฒะฟะปะธะฒะฐั ะฝะฐ ะฒะธั ัะดะฝะธะน ะบะปะฐั.

ะขัั ั ะฟัะพะฐะฝะฐะปัะทัะฒะฐะฒ ััะทะฝะธัั ะผัะถ comparable ั Comparator ั ะฒัะตะฑััะฝะพ ะพััะฝะธะฒ ัั ะฝั ะฟะปััะธ ัะฐ ะผัะฝััะธ.
ะฉะพ ะฟะพััะฒะฝัััััั ะฒ Java?
ะะพััะฒะฝัะฒะฐะฝะธะน in Java ัะต ะพะฑ'ัะบั, ัะบะธะน ะฟะพััะฒะฝัั ัะตะฑะต ะท ัะฝัะธะผ ะพะฑ'ัะบัะพะผ. ะะพะฟะพะผะฐะณะฐั ัะพัััะฒะฐัะธ ัะฟะธัะพะบ ะฟัะธะทะฝะฐัะตะฝะธั
ะดะปั ะบะพัะธัััะฒะฐัะฐ ะพะฑโัะบััะฒ. The Java.lang.ะะพััะฒะฝัะปัะฝะธะน ัะฝัะตััะตะนั ะผะฐั ะฑััะธ ัะตะฐะปัะทะพะฒะฐะฝะธะน ะบะปะฐัะพะผ, ัะพะฑ ะฟะพััะฒะฝัะฒะฐัะธ ะนะพะณะพ ะตะบะทะตะผะฟะปััะธ. ะะฐัะธะฒ ะพะฑโัะบััะฒ, ัะพ ัะตะฐะปัะทัััั ะฟะพััะฒะฝัะฝะฝะธะน ัะฝัะตััะตะนั, ัะพัััััััั ะฐะฒัะพะผะฐัะธัะฝะพ ะทะฐ Arrays.sort ัะฐ Collections.sort ะผะตัะพะดะธ
ะะตัะพะด, ะฒะธะบะพัะธััะฐะฝะธะน ั Comparable
ะฏ ั ะพััะฒ ะฑะธ ะฒะธะดัะปะธัะธ ะฒะฐะถะปะธะฒะธะน ะผะตัะพะด, ัะบะธะน ั ัะฐััะพ ะฒะธะบะพัะธััะพะฒัั ะฒ ัะฝัะตััะตะนัั Comparable:
CompareTo():
ะะตัะพะด CompareTo() ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะฟัะธัะพะดะฝะพะณะพ ัะพัััะฒะฐะฝะฝั ััะดะบะฐ. ะะฝะฐัะตะฝะฝั ะฟัะธัะพะดะฝะพะณะพ ัะพัััะฒะฐะฝะฝั โ ัะต ะฟะพััะดะพะบ ัะพัััะฒะฐะฝะฝั, ัะบะธะน ะทะฐััะพัะพะฒัััััั ะดะพ ะพะฑโัะบัะฐ, ะฝะฐะฟัะธะบะปะฐะด, ัะธัะปะพะฒะธะน ะฟะพััะดะพะบ ะดะปั ัะพัััะฒะฐะฝะฝั ััะปะธั ัะธัะตะป, ะฐะปัะฐะฒััะฝะธะน ะฟะพััะดะพะบ ะดะปั String ัะพัะพ.
ะกะธะฝัะฐะบัะธั CompareTo() ะผะตัะพะด ัะฐะบะธะน:
int compareTo(T obj)
ะฃ ะฝะฐะฒะตะดะตะฝะพะผั ะฒะธัะต ัะธะฝัะฐะบัะธัั T ะพะทะฝะฐัะฐั ัะธะฟ ะพะฑโัะบััะฒ, ัะบั ะฒะธ ะทะฑะธัะฐััะตัั ะฟะพััะฒะฝัะฒะฐัะธ.
CompareTo() ะผะตัะพะด ะฟะพััะฒะฝัั ะพะฑ'ัะบั ะท T obj.
ะฒะธั ัะด:
- ะัะฝ ะฟะพะฒะตััะฐั 0, ัะบัะพ ะทะฝะฐัะตะฝะฝั ััะฒะฝั.
- ะฏะบัะพ ะพะฑโัะบั ะผะฐั ะฝะธะถัะต ะทะฝะฐัะตะฝะฝั, ัะพ ัะตะน ะผะตัะพะด ะฟะพะฒะตััะฐั ะฒัะดโัะผะฝะต ะทะฝะฐัะตะฝะฝั.
- ะฏะบัะพ ะพะฑโัะบั ะผะฐั ะฑัะปััะต ะทะฝะฐัะตะฝะฝั, ะฒัะฝ ะฟะพะฒะตััะฐั ะดะพะดะฐัะฝะต ะทะฝะฐัะตะฝะฝั.
ะัะธะบะปะฐะด ะฟะพััะฒะฝัะฝะฝะพะณะพ ะฒ Java
ะะฐัััะฟะฝะฐ ะฟัะพะณัะฐะผะฐ Java ะฟะพััะฒะฝัะปัะฝะธะน ะฟัะธะบะปะฐะด ะฟะพะบะฐะทัั ะฟะพััะฒะฝัะฝะฝั ะดะฒะพั ัะธะผะฒะพะปัะฒ ยซaยป ั ยซbยป. ะกะธะผะฒะพะป ยซะฐยป ััะพััั ะฟะตัะตะด ยซะฑยป ะทะฐ ะฐะปัะฐะฒััะพะผ.
ะัะถะต, ะฒะธั ัะด ะดะพััะฒะฝัั -1. ะกะธะผะฒะพะป ยซbยป ััะพััั ะฟััะปั ยซaยป ะทะฐ ะฐะปัะฐะฒััะพะผ. ะัะถะต, ัะตะทัะปััะฐัะพะผ ะฑัะดะต 1. ะกะธะผะฒะพะปะธ ยซaยป ั ยซbยป ั ะตะบะฒัะฒะฐะปะตะฝัะฝะธะผะธ. ะัะถะต, ะฒะธั ัะด ะดะพััะฒะฝัั 0.
public class Sample_String {
public static void main(String[] args) {
String str_Sample = "a";
System.out.println("Compare To 'a' b is : " + str_Sample.compareTo("b"));
str_Sample = "b";
System.out.println("Compare To 'b' a is : " + str_Sample.compareTo("a"));
str_Sample = "b";
System.out.println("Compare To 'b' b is : " + str_Sample.compareTo("b"));
}
}
ะะธั ัะด
Compare To 'a' b is : -1 Compare To 'b' a is : 1 Compare To 'b' b is : 0
ะฉะพ ัะฐะบะต ะบะพะผะฟะฐัะฐัะพั ะฒ Java?
ะะพะผะฟะฐัะฐัะพั in Java ั ะพะฑ'ัะบัะพะผ ะดะปั ะฟะพััะฒะฝัะฝะฝั ััะทะฝะธั ะพะฑ'ัะบััะฒ ััะทะฝะธั ะบะปะฐััะฒ. ะะฝัะตััะตะนั ะบะพะผะฟะฐัะฐัะพัะฐ ะฒ Java ัะฐะบะพะถ ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะฒะฟะพััะดะบัะฒะฐะฝะฝั ะพะฑ'ัะบััะฒ ะฒะธะทะฝะฐัะตะฝะธั ะบะพัะธัััะฒะฐัะตะผ ะบะปะฐััะฒ. ะัะฝ ะฒะบะปััะฐั ะดะฒะฐ ะฒะฐะถะปะธะฒั ะผะตัะพะดะธ ัะฝัะตััะตะนัั ะบะพะผะฟะฐัะฐัะพัะฐ, ะฒัะดะพะผั ัะบ ะฟะพััะฒะฝัะฝะฝั (Object obj1, Object obj2) ั ะดะพััะฒะฝัั (Object element).
ะะตัะพะด, ะฒะธะบะพัะธััะฐะฝะธะน ั Comparator
ะฃ ัะฒะพัะน ะฟัะฐะบัะธัั ั ัะฐััะพ ะฟะพะบะปะฐะดะฐััั ะฝะฐ ะฝะฐัััะฟะฝั ะบัะธัะธัะฝั ะผะตัะพะดะธ ัะฝัะตััะตะนัั ะบะพะผะฟะฐัะฐัะพัะฐ:
ะะพััะฒะฝััะธ():
Compare() ะดะพะทะฒะพะปัั ะทะฐะผะพะฒะปััะธ ะพะฑ'ัะบัะธ. ะะปั ััะพะณะพ ะฒะฐะผ ะฟะพัััะฑะฝะพ ััะฒะพัะธัะธ ะบะปะฐั, ัะบะธะน ัะตะฐะปัะทัั ัะฝัะตััะตะนั ะบะพะผะฟะฐัะฐัะพัะฐ. ะััะปั ััะพะณะพ ะฒะฐะผ ะฟะพัััะฑะฝะพ ะฟะตัะตะฒะธะทะฝะฐัะธัะธ ะนะพะณะพ ะผะตัะพะด ะฟะพััะฒะฝัะฝะฝั.
ะกะธะฝัะฐะบัะธั compare() ะผะตัะพะด ัะฐะบะธะน:
compare(Object obj1, Object obj2)
ะฃ ะฝะฐะฒะตะดะตะฝะพะผั ะฒะธัะต ัะธะฝัะฐะบัะธัั obj1 ั obj2 โ ัะต ะดะฒะฐ ะพะฑโัะบัะธ, ัะบั ะฟะพัััะฑะฝะพ ะฟะพััะฒะฝััะธ ะทะฐ ะดะพะฟะพะผะพะณะพั ะผะตัะพะดั compare(). compare() ะผะตัะพะด.
ะฒะธั ัะด:
- ะัะฝ ะฟะพะฒะตััะฐั ะฒัะดโัะผะฝะต ััะปะต ัะธัะปะพ, ัะบัะพ ะฟะตััะธะน ะฐัะณัะผะตะฝั ะผะตะฝัะธะน ะทะฐ ะดััะณะธะน.
- ะะพะฒะตััะฐั ะฝัะปั, ัะบัะพ ะฟะตััะธะน ั ะดััะณะธะน ะฐัะณัะผะตะฝัะธ ััะฒะฝั.
- ะฆะตะน ะผะตัะพะด ะผะพะถะต ะฟะพะฒะตัะฝััะธ ะดะพะดะฐัะฝะต ััะปะต ัะธัะปะพ, ัะบัะพ ะฟะตััะธะน ะฐัะณัะผะตะฝั ะฑัะปััะธะน ะทะฐ ะดััะณะธะน.
ะะธ ะฟะพะฒะธะฝะฝั ะฟะตัะตะบะพะฝะฐัะธัั, ัะพ ะฒัะดะฝะพัะตะฝะฝั ั ััะฐะฝะทะธัะธะฒะฝะธะผ. ะะฐะฟัะธะบะปะฐะด, ((ะฟะพััะฒะฝัะนัะต(a, b)>0) && (ะฟะพััะฒะฝัะนัะต(b, c)>0)), ัะพ ะฟะตัะตะดะฑะฐัะฐั ะฟะพััะฒะฝัะฝะฝั(a, c)>0.
ะัะธะบะปะฐะด ะฟะพััะฒะฝัะฝะฝะพะณะพ ะฒ Java
ะะธะถัะต Java ะฟัะธะบะปะฐะด ะบะพะผะฟะฐัะฐัะพัะฐ, ัั 6 ะทะผัะฝะฝั. ยซxยป, ยซyยป, ยซpยป, ยซqยป, ยซrยป ั ยซsยป. ะะธั ัะด ะดะพััะฒะฝัั -1 ัะบ ะทะฝะฐัะตะฝะฝั โxโ, 20 ะผะตะฝัะต ะทะฝะฐัะตะฝะฝั โyโ, 30. ะะธั ัะด ะดะพััะฒะฝัั 0, ะพัะบัะปัะบะธ ะทะฝะฐัะตะฝะฝั โpโ, 40 ะดะพััะฒะฝัั ะทะฝะฐัะตะฝะฝั โqโ, 40 .
import java.lang.Integer;
public class example {
public static void main(String args[])
{
int x = 20;
int y = 30;
// as 10 less than 20,
// Output will be a value less than zero
System.out.println(Integer.compare(x, y));
int p = 40;
int q = 40;
// as 30 equals 30,
// Output will be zero
System.out.println(Integer.compare(p, q));
int r = 20;
int s = 7;
// as 15 is greater than 8,
// Output will be a value greater than zero
System.out.println(Integer.compare(r, s));
}
}
ะฒะธั ัะด:
-1 0 1
ะะพััะฒะฝัั():
Equals() ะฟะตัะตะฒัััั, ัะธ ะดะพััะฒะฝัั ัะธัะตะปัะฝะธะน ะพะฑ'ัะบั ะพะฑ'ัะบัั, ัะบะธะน ะฟะตัะตะดะฐััััั ัะบ ะฐัะณัะผะตะฝั, ัะธ ะฝั.
ะกะธะฝัะฐะบัะธั equals() ะผะตัะพะด ัะฐะบะธะน:
public boolean equals(Object o)
ะฆะตะน ะผะตัะพะด ะฟัะธะนะผะฐั ะดะฒะฐ ะฟะฐัะฐะผะตััะธ: 1) ะฑัะดั-ัะบะธะน ะพะฑโัะบั ั 2) ะทะฝะฐัะตะฝะฝั, ัะพ ะฟะพะฒะตััะฐััััั. ะัะฝ ะฟะพะฒะตััะฐั ัััะธะฝั, ัะบัะพ ะฟะตัะตะดะฐะฝะธะน ะฐัะณัะผะตะฝั ะฝะต ั ะฝัะปัะพะฒะธะผ ั ั ะพะฑโัะบัะพะผ ะฟะพะดัะฑะฝะพะณะพ ัะธะฟั ะท ัะฐะบะธะผ ัะฐะผะธะผ ัะธัะปะพะฒะธะผ ะทะฝะฐัะตะฝะฝัะผ.
ะัะธะบะปะฐะด ะผะตัะพะดั Equals:
ะฃ ะฝะฐะฒะตะดะตะฝะพะผั ะฝะธะถัะต ะฟัะธะบะปะฐะดั ั ะฑัะดั ะฟะพััะฒะฝัะฒะฐัะธ ัะพัะธัะธ ะทะผัะฝะฝั ะพะดะฝะฐ ะท ะพะดะฝะพั. ะขัะธ ะทะผัะฝะฝั ะผะฐััั ัะธะฟ integer, ะฐ ะพะดะฝะฐ โ ัะธะฟ short. ะะตััะธะน ัะตะทัะปััะฐั ั ั ะธะฑะฝะธะผ, ะพัะบัะปัะบะธ ะทะฝะฐัะตะฝะฝั p, ัะบะต ะดะพััะฒะฝัั 5, ะฝะต ะดะพััะฒะฝัั ะทะฝะฐัะตะฝะฝั q, ัะบะต ะดะพััะฒะฝัั 20.
ะััะณะธะน ัะตะทัะปััะฐั ั ัััะธะฝะฝะธะผ, ัะพะผั ัะพ ะทะฝะฐัะตะฝะฝั ะทะผัะฝะฝะธั p ั r ะพะดะฝะฐะบะพะฒั, ัะพะฑัะพ 5. ะะฐัะตััั, ัะตะทัะปััะฐั ั ั ะธะฑะฝะธะผ, ะพัะบัะปัะบะธ ะทะผัะฝะฝั p ั s ะผะฐััั ััะทะฝั ะฟัะธัะฒะพัะฝั ะทะฝะฐัะตะฝะฝั.
public class Test {
public static void main(String args[]) {
Integer p = 5;
Integer q = 20;
Integer r =5;
Short s = 5;
System.out.println(p.equals(q));
System.out.println(p.equals(r));
System.out.println(p.equals(s));
}
}
ะะธั ัะด
false true false
ะัะดะผัะฝะฝะพััั ะผัะถ Comparable ั Comparator ะฒ Java
ะฏ ัะฐััะพ ะฑะฐัั ะฟะปััะฐะฝะธะฝั ะผัะถ Java Comparable ั Comparator; ะพัั ะณะพะปะพะฒะฝะฐ ะฒัะดะผัะฝะฝัััั:

| ะัะฝะพะฒะฐ ะฟะพััะฒะฝัะฝะฝั | ะะพััะฒะฝัะฒะฐะฝะธะน | ะบะพะผะฟะฐัะฐัะพั |
|---|---|---|
| ะะตัะพะด | ะะพััะฒะฝัะฝะฝั ะทะฐะฑะตะทะฟะตััััั compareTo() ะผะตัะพะด ัะพัััะฒะฐะฝะฝั ะตะปะตะผะตะฝััะฒ Java. |
ะะพะผะฟะฐัะฐัะพั ะทะฐะฑะตะทะฟะตััั compare() ะผะตัะพะด ัะพัััะฒะฐะฝะฝั ะตะปะตะผะตะฝััะฒ Java. |
| ะฟะฐะบะตั | ะะพะดัะฑะฝะธะน ัะฝัะตััะตะนั ะฟัะธัััะฝัะน ั java.lang ะฟะฐะบะตั. |
ะะฝัะตััะตะนั ะบะพะผะฟะฐัะฐัะพัะฐ ะฟัะธัััะฝัะน ั java.util ะฟะฐะบะตั. |
| ะะพะณัะบะฐ ัะพัััะฒะฐะฝะฝั | ะะพะณัะบะฐ ัะพัััะฒะฐะฝะฝั ะผะฐั ะฑััะธ ะฒ ัะพะผั ะถ ะบะปะฐัั, ัะพ ะน ะพะฑโัะบั, ัะบะธะน ะฒะธ ะทะฑะธัะฐััะตัั ัะพัััะฒะฐัะธ. | ะะพะณัะบะฐ ัะพัััะฒะฐะฝะฝั ะฟะพะฒะธะฝะฝะฐ ะฑััะธ ะฒ ะพะบัะตะผะธั ะบะปะฐัะฐั ะดะปั ะทะฐะฟะธัั ััะทะฝะธั ัะพัััะฒะฐะฝั ะฝะฐ ะพัะฝะพะฒั ััะทะฝะธั ะฐััะธะฑัััะฒ ะพะฑ'ัะบััะฒ. |
| ะะฑ'ัะบั ะบะปะฐัั | ะะปะฐั, ะพะฑ'ัะบัะธ ัะบะพะณะพ ะฒะธ ั ะพัะตัะต ะฒัะดัะพัััะฒะฐัะธ, ะฟะพะฒะธะฝะตะฝ ัะตะฐะปัะทะพะฒัะฒะฐัะธ ัะฝัะตััะตะนั Comparable. | ะะปะฐั, ะพะฑโัะบัะธ ัะบะพะณะพ ะฒะธ ั ะพัะตัะต ะฒัะดัะพัััะฒะฐัะธ, ะฝะต ะฟะพััะตะฑัั ัะตะฐะปัะทะฐััั ัะฝัะตััะตะนัั ะฟะพััะฒะฝัะฝะฝั. |
| ะะพัะปัะดะพะฒะฝะพััั ัะพัััะฒะฐะฝะฝั | ะัะฝ ะทะฐะฑะตะทะฟะตััั ะพะดะฝั ะฟะพัะปัะดะพะฒะฝัััั ัะพัััะฒะฐะฝะฝั. | ะัะฝ ะทะฐะฑะตะทะฟะตััั ะบัะปัะบะฐ ะฟะพัะปัะดะพะฒะฝะพััะตะน ัะพัััะฒะฐะฝะฝั. |
| ะะพััะดะพะบ ัะพัััะฒะฐะฝะฝั | ะฆะตะน ะผะตัะพะด ะผะพะถะต ัะพัััะฒะฐัะธ ะดะฐะฝั ะฒัะดะฟะพะฒัะดะฝะพ ะดะพ ะฟัะธัะพะดะฝะพะณะพ ะฟะพััะดะบั ัะพัััะฒะฐะฝะฝั. | ะฆะตะน ะผะตัะพะด ัะพัััั ะดะฐะฝั ะฒัะดะฟะพะฒัะดะฝะพ ะดะพ ะฝะฐะปะฐััะพะฒะฐะฝะพะณะพ ะฟะพััะดะบั ัะพัััะฒะฐะฝะฝั. |
| ะะปะฐั | ะฆะต ะฒะฟะปะธะฒะฐั ะฝะฐ ะฟะพัะฐัะบะพะฒะธะน ะบะปะฐั. ัะพะฑัะพ ัะฐะบัะธัะฝะธะน ะบะปะฐั ะทะผัะฝัััััั. | ะฆะต ะฝะต ะฒะฟะปะธะฒะฐั ะฝะฐ ะฒะธั ัะดะฝะธะน ะบะปะฐั, ัะพะฑัะพ ัะฐะบัะธัะฝะธะน ะบะปะฐั ะฝะต ะทะผัะฝัััััั. |
| ะะธะบะพัะธััะฐะฝะฝั | ะงะฐััะพ ัะตะฐะปัะทัััััั ะฒ API ะบะฐะปะตะฝะดะฐัะตะผ, ะบะปะฐัะฐะผะธ ะพะฑะพะปะพะฝะบะธ, ะดะฐัะพั ัะฐ ะ ัะดะพะบ. |
ะัะฝ ัะตะฐะปัะทะพะฒะฐะฝะธะน ะดะปั ัะพัััะฒะฐะฝะฝั ะตะบะทะตะผะฟะปัััะฒ ััะพัะพะฝะฝัั ะบะปะฐััะฒ. |
| ะะดัะนัะฝัะฒะฐัะธ | ะฃัั ะบะปะฐัะธ-ะพะณะพััะบะธ ัะฐ ะบะปะฐัะธ ััะดะบัะฒ ัะตะฐะปัะทัััั ะฟะพััะฒะฝัะปัะฝั ัะฝัะตััะตะนัะธ. | ะะดะธะฝะธะผะธ ัะตะฐะปัะทะพะฒะฐะฝะธะผะธ ะบะปะฐัะฐะผะธ Comparator ั Collator ั RuleBasedColator. |
ะะฐะนะบัะฐัั ะฟัะฐะบัะธะบะธ ะฟัะด ัะฐั ะฒะธะบะพัะธััะฐะฝะฝั Comparator ั Comparable ะฒ Java
- ะะธะบะพัะธััะพะฒัะนัะต ะฟะพััะฒะฝัะปัะฝะธะน ัะฝัะตััะตะนั, ัะบัะพ ะฟะพััะฒะฝัะฝะฝั ั ััะฐะฝะดะฐััะฝะธะผ ะดะปั ะบะพะฝะบัะตัะฝะพะณะพ ะบะปะฐัั.
- ะะธ ะผะพะถะตัะต ะฒะธะบะพัะธััะพะฒัะฒะฐัะธ ะปัะผะฑะดะฐ-ะฒะธัะฐะทะธ ะท ะบะพะผะฟะฐัะฐัะพัะพะผ.
- ะะฐะณะฐัะพ ะท ะดะพัััะฟะฝะธั ะพัะฝะพะฒะฝะธั ะบะปะฐััะฒ ัะตะฐะปัะทัััั ะฟะพััะฒะฝัะฝะฝะธะน ัะฝัะตััะตะนั.
- ะะพะถะฝะฐ ะฒะธะบะพัะธััะพะฒัะฒะฐัะธ TreeSet ั TreeMap ะฟัะด ัะฐั ัะพัััะฒะฐะฝะฝั Set ะฐะฑะพ Map.
- ะะพะผะฐะฝะดะฐ
compareTo()ะผะตัะพะด ะฟัะฐััั ัะบ ะท ะบะพะผะฟะฐัะฐัะพัะพะผ, ัะฐะบ ั ะท ะบะพะผะฟะฐัะฐัะพัะพะผ. - ะะธะบะพัะธััะพะฒัะนัะต ัะฝัะตััะตะนั ะบะพะผะฟะฐัะฐัะพัะฐ ะปะธัะต ัะพะดั, ะบะพะปะธ ะฒะฐะผ < ะฟะพัััะฑะฝะฐ ะฑัะปััะฐ ะณะฝััะบัััั.
- ะะพะผะฐะฝะดะฐ
compareTo()ะผะตัะพะด ะฟะพะฒะตัะฝะต ะดะพะดะฐัะฝะต ััะปะต ัะธัะปะพ, ัะบัะพ ะฟะตััะธะน ะพะฑโัะบั ะฑัะปััะธะน ะทะฐ ัะฝัะธะน, ะฒัะดโัะผะฝะต, ัะบัะพ ะฒัะฝ ะฝะธะถัะธะน, ั ะฝัะปั, ัะบัะพ ะพะฑะธะดะฒะฐ ะพะดะฝะฐะบะพะฒั.
ะฏะบ ะฒะธะฑัะฐัะธ ะผัะถ ะฟะพััะฒะฝัะฒะฐะฝะธะผ ั ะฟะพััะฒะฝัะฒะฐะฝะธะผ
ะัะตััะพั, ะผัะน ะฟัะฐะบัะธัะฝะธะน ะดะพัะฒัะด ะฟะพะบะฐะทัั, ัะพ ะฒะธะบะพัะธััะฐะฝะฝั Comparable ั Comparator ั Java ะทะฝะฐัะฝะพ ะฟะพะบัะฐััั ะบะพะฝััะพะปั ะฝะฐะด ัะพัััะฒะฐะฝะฝัะผ ะดะฐะฝะธั , ะฟัะดะฒะธััััะธ ะฟัะพะดัะบัะธะฒะฝัััั ั ััะฝะบััะพะฝะฐะปัะฝัััั.
