కంపారేటర్, సార్టింగ్ సేకరణలు

"హాయ్, అమిగో!"

"హాయ్, బిలాబో!"

"ఈ రోజు మనం ఒక చిన్న, కానీ ఆసక్తికరమైన మరియు ఉపయోగకరమైన అంశాన్ని పరిశీలిస్తాము: సేకరణలను క్రమబద్ధీకరించడం."

"క్రమబద్ధీకరించడం? నేను దాని గురించి ఏదో విన్నాను."

"చాలా కాలం క్రితం, ప్రతి ప్రోగ్రామర్ సార్టింగ్ అల్గారిథమ్‌లను వ్రాయగలగాలి. వాటిని వ్రాయగలిగాడు మరియు వ్రాయవలసి వచ్చింది. కానీ ఆ రోజులు ముగిశాయి. ఈ రోజు, మీ స్వంత సార్టింగ్ కోడ్‌ను వ్రాయడం చెడ్డ రూపంగా పరిగణించబడుతుంది, ఇది ఇప్పటికే ఉన్న ఏదైనా తిరిగి వ్రాయడం వంటిది. కనుగొనబడింది."

"జావాలో (మరియు ఇతర ప్రోగ్రామింగ్ భాషలలో), సార్టింగ్ ఇప్పటికే అమలు చేయబడింది.  ఇప్పటికే ఉన్నవాటిని సరిగ్గా ఎలా ఉపయోగించాలో తెలుసుకోవడమే మీ పని. "

"అలాగే."

" కలెక్షన్స్ హెల్పర్ క్లాస్‌లో స్టాటిక్ క్రమబద్ధీకరణ పద్ధతి ఉంది, ఇది సేకరణలను క్రమబద్ధీకరించడానికి లేదా మరింత ఖచ్చితంగా జాబితాలను క్రమబద్ధీకరించడానికి ఉపయోగించబడుతుంది. మ్యాప్స్ మరియు సెట్‌లలోని ఎలిమెంట్‌లకు ఆర్డర్/ఇండెక్స్ లేదు, కాబట్టి క్రమబద్ధీకరించడానికి ఏమీ లేదు."

"అవును, నాకు గుర్తుంది. సంఖ్యల జాబితాను క్రమబద్ధీకరించడానికి నేను ఈ పద్ధతిని ఒకసారి ఉపయోగించాను."

"అద్భుతమైనది. కానీ ఈ పద్ధతి మొదటి చూపులో కనిపించే దానికంటే చాలా శక్తివంతమైనది. ఇది సంఖ్యలను మాత్రమే కాకుండా, ఏదైనా ప్రమాణాల ఆధారంగా ఏదైనా వస్తువులను కూడా క్రమబద్ధీకరించగలదు. దీన్ని చేయడానికి రెండు ఇంటర్‌ఫేస్‌లు ఈ పద్ధతికి సహాయపడతాయి: పోల్చదగిన మరియు కంపారేటర్ . "

"కొన్నిసార్లు మీరు వస్తువులను క్రమబద్ధీకరించాలి, సంఖ్యలను కాదు. ఉదాహరణకు, మీరు వ్యక్తుల జాబితాను కలిగి ఉన్నారని అనుకుందాం మరియు మీరు వాటిని వయస్సు ప్రకారం క్రమబద్ధీకరించాలనుకుంటున్నాము. దీని కోసం మా వద్ద పోల్చదగిన ఇంటర్‌ఫేస్ ఉంది."

"మొదట నేను మీకు ఒక ఉదాహరణ చూపుతాను, ఆపై ప్రతిదీ స్పష్టంగా మారుతుంది:"

public class Woman implements Comparable<Woman>
{
public int age;

public Woman(int age) {
this.age = age;
}

public int compareTo(Woman o)
{
return this.age - o.age;
}
}

public static void main(String[] args )
{
ArrayList<Woman> women = new ArrayList<Woman>();
women.add(new Woman(18));
women.add(new Woman(21));
women.add(new Woman(5));

Collections.sort(women);
}

"వస్తువులను క్రమబద్ధీకరించడానికి, మీరు మొదట వాటిని ఎలా పోల్చాలో తెలుసుకోవాలి. దీని కోసం, మేము కంపేరబుల్‌ని ఉపయోగిస్తాము. పోల్చదగిన ఇంటర్‌ఫేస్ సాధారణమైనది, అంటే ఇది ఒక రకమైన వాదనను అంగీకరిస్తుంది. దీనికి ఒకే ఒక సాధారణ పద్ధతి ఉంది: compareTo(T o). ఈ పద్ధతి ప్రస్తుత ఆబ్జెక్ట్ (ఇది) మరియు ఆర్గ్యుమెంట్ (o)గా పాస్ చేసిన ఆబ్జెక్ట్‌ను పోలుస్తుంది. మరో మాటలో చెప్పాలంటే, ఈ పద్ధతిని మన తరగతిలో అమలు చేయాలి మరియు ఆపై పాస్ చేసిన ఆబ్జెక్ట్‌తో ప్రస్తుత వస్తువు (ఇది) పోల్చడానికి ఉపయోగించాలి. "

"మరియు compareTo ఎలా పని చేస్తుంది? పాస్ చేసిన వస్తువు పెద్దదా లేదా చిన్నదా అనేదానిపై ఆధారపడి అది నిజం లేదా తప్పుగా తిరిగి వస్తుందని నేను ఊహించాను."

"ఇక్కడ విషయాలు చాలా గమ్మత్తైనవి. compareTo పద్ధతి నిజం/తప్పుని అందించదు. బదులుగా, ఇది ఒక పూర్ణాంకాన్ని అందిస్తుంది. ఇది వాస్తవానికి సరళత కోసం చేయబడుతుంది.

"కంప్యూటర్ ఒక సంఖ్య మరొకదాని కంటే ఎక్కువగా ఉందో లేదో గుర్తించాల్సిన అవసరం వచ్చినప్పుడు, అది మొదటి సంఖ్య నుండి రెండవ సంఖ్యను తీసివేసి, ఆపై ఫలితాన్ని చూస్తుంది. ఫలితం 0 అయితే, సంఖ్యలు సమానంగా ఉంటాయి. ఫలితం సున్నా కంటే తక్కువగా ఉంటే. , అప్పుడు రెండవ సంఖ్య ఎక్కువ. మరియు ఫలితం సున్నా కంటే ఎక్కువగా ఉంటే, మొదటి సంఖ్య ఎక్కువగా ఉంటుంది."

"ఇక్కడ కూడా అదే లాజిక్ వర్తిస్తుంది. స్పెసిఫికేషన్ ప్రకారం, పోల్చబడిన వస్తువులు సమానంగా ఉంటే compareTo పద్ధతి తప్పనిసరిగా సున్నాని అందించాలి. compareTo పద్ధతి సున్నా కంటే ఎక్కువ సంఖ్యను అందిస్తే, మన వస్తువు పాస్ చేసిన వస్తువు కంటే ఎక్కువగా ఉంటుంది. "compareTo అయితే పద్ధతి సున్నా కంటే తక్కువ సంఖ్యను అందిస్తుంది, ఆపై 'ఇది' పాస్ చేసిన వస్తువు కంటే తక్కువగా ఉంటుంది."

"అది కొంచెం విచిత్రం."

"అవును, కానీ మీరు కేవలం కొన్ని సంఖ్యా ప్రాపర్టీ ఆధారంగా వస్తువులను పోలుస్తుంటే, మీరు ఒకదాని నుండి మరొకటి తీసివేయడం ద్వారా వాటి మధ్య వ్యత్యాసాన్ని తిరిగి ఇవ్వవచ్చు. పై ఉదాహరణలో చేసిన విధంగానే."

public int compareTo(Woman o)
{
return this.age - o.age;
}

"నేను ప్రతిదీ అర్థం చేసుకున్నాను. కానీ కాకపోవచ్చు. కానీ దాదాపు ప్రతిదీ."

"అద్భుతమైనది. ఇప్పుడు మరింత ఆచరణాత్మక సమస్యను పరిశీలిద్దాం. మీరు చైనాలో మహిళల దుస్తులను తయారు చేయడానికి ఒక చక్కని వెబ్‌సైట్‌ను వ్రాసారని అనుకుందాం. మీరు మీ కస్టమర్‌లను వివరించడానికి ఉమెన్ క్లాస్‌ని ఉపయోగిస్తున్నారు. మీరు వారందరినీ చూడగలిగే పట్టికతో వెబ్‌పేజీని కూడా చేసారు. . కానీ ఒక సమస్య ఉంది..."

"మీ స్త్రీ ఆబ్జెక్ట్ వయస్సు మాత్రమే కాకుండా, ఇతర డేటా యొక్క మొత్తం సమూహాన్ని కూడా కలిగి ఉంది: మొదటి పేరు, చివరి పేరు, ఎత్తు, బరువు, పిల్లల సంఖ్య మొదలైనవి."

"వినియోగదారుల పట్టికలో చాలా నిలువు వరుసలు ఉన్నాయి మరియు ఇక్కడ ప్రశ్న ఉంది: మీరు మీ వినియోగదారులను వివిధ ప్రమాణాల ద్వారా ఎలా క్రమబద్ధీకరిస్తారు? బరువు, వయస్సు, ఇంటిపేరు ద్వారా?"

"హ్మ్. అవును, మీరు నిలువు వరుసల వారీగా క్రమబద్ధీకరించడానికి అనుమతించే పట్టికలను నేను తరచుగా చూస్తాను. కాబట్టి, మీరు దీన్ని ఎలా చేస్తారు?"

"దీని కోసం, ఈ రోజు గురించి నేను మీకు చెప్పాలనుకున్న రెండవ ఇంటర్‌ఫేస్ ఉంది: కంపారిటర్ ఇంటర్‌ఫేస్. దీనికి కంపేర్ మెథడ్ కూడా ఉంది, కానీ దీనికి ఒకటి కాదు రెండు ఆర్గ్యుమెంట్‌లు అవసరం: int compare(T o1, T o2). ఇది ఎలా ఉంది పనిచేస్తుంది:"

public class Woman
{
public int age;
public int childrenCount;
public int weight;
public int height;
public String name;

public Woman(int age) {
this.age = age;
}
}

public static void main(String[] args )
{
ArrayList<Woman> women = new ArrayList<Woman>();
women.add(new Woman(18));
women.add(new Woman(21));
women.add(new Woman(5));

Comparator<Woman> compareByHeight = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.height - o2.height;
}
};

Collections.sort(women, compareByHeight);
}

"కంపారిటర్ ఇంటర్‌ఫేస్ ఆబ్జెక్ట్ కంపారిజన్ లాజిక్‌ను పోల్చిన ఆబ్జెక్ట్‌ల క్లాస్‌లో దాచదు. బదులుగా, ఇది ప్రత్యేక తరగతిలో అమలు చేయబడుతుంది."

"కాబట్టి, నేను కంపారిటర్ ఇంటర్‌ఫేస్‌ను అమలు చేసే అనేక తరగతులను తయారు చేయగలను మరియు వాటిలో ప్రతి ఒక్కటి విభిన్న లక్షణాలను పోల్చగలవా? ఒకదానిలో బరువు, మరొకదానిలో వయస్సు మరియు మూడవదానిలో ఎత్తు?"

"అవును, ఇది చాలా సులభం మరియు అనుకూలమైనది."

"మేము కేవలం Collections.sort పద్ధతిని పిలుస్తాము , ఆబ్జెక్ట్‌ల జాబితాను మరియు మరొక ప్రత్యేక వస్తువును రెండవ ఆర్గ్యుమెంట్‌గా పంపుతాము, ఇది కంపారిటర్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది మరియు సార్టింగ్ ప్రక్రియలో వస్తువుల జతలను ఎలా సరిగ్గా సరిపోల్చాలో మీకు తెలియజేస్తుంది."

"హ్మ్. నేను ప్రతిదీ అర్థం చేసుకున్నాను అని అనుకుంటున్నాను. నేను ఒకసారి ప్రయత్నిద్దాం. నేను వినియోగదారులను బరువును బట్టి క్రమబద్ధీకరించాలని అనుకుందాం. ఇది ఇలా ఉంటుంది:"

Comparator<Woman> compareByWeight = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.weight - o2.weight;
}
};

Collections.sort(women, compareByWeight);

"అవును ఖచ్చితంగా."

"గ్రేట్. అయితే నేను రివర్స్ ఆర్డర్‌లో క్రమబద్ధీకరించాలనుకుంటే?"

"ఆలోచించండి. సమాధానం చాలా సులభం!"

"నాకు వచ్చింది! ఇలా:"

return o1.weight - o2.weight;

return o2.weight – o1.weight;

"రైట్. బాగా చేసారు."

"మరియు నేను ఇంటిపేరుతో క్రమబద్ధీకరించాలనుకుంటే? నేను తీగలను ఎలా క్రమబద్ధీకరించాలి, బిలాబో?"

"స్ట్రింగ్ క్లాస్ ఇప్పటికే compareTo పద్ధతిని అమలు చేస్తోంది. మీరు దీన్ని కాల్ చేయాలి:"

Comparator<Woman> compareByName = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.name.compareTo(o2.name);
}
};

Collections.sort(women, compareByName);

"అది గొప్ప పాఠం, బిలాబో. చాలా ధన్యవాదాలు."

"మరియు మీకు ధన్యవాదాలు, నా మిత్రమా!"