ஒப்பீட்டாளர், சேகரிப்புகளை வரிசைப்படுத்துதல்

"வணக்கம், அமிகோ!"

"வணக்கம், பிலாபோ!"

"இன்று நாம் ஒரு சிறிய, ஆனால் சுவாரஸ்யமான மற்றும் பயனுள்ள தலைப்பை ஆராய்வோம்: சேகரிப்புகளை வரிசைப்படுத்துதல்."

"வரிசைப்படுத்துகிறதா? அதைப் பற்றி நான் கேள்விப்பட்டிருக்கிறேன்."

"நீண்ட காலத்திற்கு முன்பு, ஒவ்வொரு புரோகிராமரும் வரிசைப்படுத்தும் அல்காரிதம்களை எழுத வேண்டும். அவற்றை எழுத முடிந்தது. ஆனால் அந்த நாட்கள் முடிந்துவிட்டன. இன்று, உங்கள் சொந்த வரிசையாக்கக் குறியீட்டை எழுதுவது மோசமான வடிவமாகக் கருதப்படுகிறது, ஏற்கனவே உள்ள வேறு எதையும் மீண்டும் எழுதுவது போல. கண்டுபிடிக்கப்பட்டது."

"ஜாவாவில் (மற்றும் பிற நிரலாக்க மொழிகளில்), வரிசையாக்கம் ஏற்கனவே செயல்படுத்தப்பட்டுள்ளது.  ஏற்கனவே உள்ளதை எவ்வாறு சரியாகப் பயன்படுத்துவது என்பதைக் கற்றுக்கொள்வது உங்கள் பணியாகும். "

"சரி."

" கலெக்ஷன்ஸ் ஹெல்பர் கிளாஸில் சேகரிப்புகளை வரிசைப்படுத்தப் பயன்படும் நிலையான வரிசை முறை உள்ளது - அல்லது இன்னும் துல்லியமாக, பட்டியல்கள். வரைபடம் மற்றும் செட்களில் உள்ள உறுப்புகளுக்கு வரிசை/இண்டெக்ஸ் இல்லை, எனவே வரிசைப்படுத்த எதுவும் இல்லை."

"ஆம், எனக்கு நினைவிருக்கிறது. எண்களின் பட்டியலை வரிசைப்படுத்த இந்த முறையை ஒருமுறை பயன்படுத்தினேன்."

"அருமையானது. ஆனால் இந்த முறை முதல் பார்வையில் தோன்றுவதை விட மிகவும் சக்தி வாய்ந்தது. இது எண்களை மட்டுமல்ல, எந்தவொரு பொருளையும், எந்த அளவுகோலின் அடிப்படையில் வரிசைப்படுத்த முடியும். இரண்டு இடைமுகங்கள் இந்த முறையைச் செய்ய உதவுகின்றன: ஒப்பிடக்கூடிய மற்றும் ஒப்பிடுபவர் . "

"சில நேரங்களில் நீங்கள் பொருட்களை வரிசைப்படுத்த வேண்டும், எண்களை அல்ல. உதாரணமாக, உங்களிடம் நபர்களின் பட்டியல் உள்ளது, மேலும் நீங்கள் அவர்களை வயதின்படி வரிசைப்படுத்த விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். இதற்கான ஒப்பிடக்கூடிய இடைமுகம் எங்களிடம் உள்ளது."

"முதலில் ஒரு உதாரணத்தைக் காட்டுகிறேன், பின்னர் எல்லாம் தெளிவாகிவிடும்:"

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 முறை உண்மை/தவறு என்பதைத் தராது. அதற்குப் பதிலாக, அது ஒரு எண்ணைத் தருகிறது. இது உண்மையில் எளிமைக்காக செய்யப்படுகிறது.

"ஒரு எண் மற்றொன்றை விட பெரியதா என்பதை ஒரு கணினி தீர்மானிக்க வேண்டியிருக்கும் போது, ​​அது முதல் எண்ணிலிருந்து இரண்டாவது எண்ணைக் கழித்து, பின்னர் முடிவைப் பார்க்கிறது. முடிவு 0 என்றால், எண்கள் சமம். முடிவு பூஜ்ஜியத்தை விட குறைவாக இருந்தால் , பின்னர் இரண்டாவது எண் அதிகமாக உள்ளது. மேலும் முடிவு பூஜ்ஜியத்தை விட அதிகமாக இருந்தால், முதல் எண் அதிகமாக இருக்கும்."

"அதே தர்க்கம் இங்கேயும் பொருந்தும். விவரக்குறிப்பின்படி, ஒப்பிடப்பட்ட பொருள்கள் சமமாக இருந்தால், compareTo முறை பூஜ்ஜியத்தை வழங்க வேண்டும். compareTo முறை பூஜ்ஜியத்தை விட அதிகமான எண்ணை வழங்கினால், எங்கள் பொருள் அனுப்பப்பட்ட பொருளை விட பெரியதாக இருக்கும். "compareTo என்றால் முறை பூஜ்ஜியத்தை விட குறைவான எண்ணை வழங்குகிறது, பின்னர் 'இது' அனுப்பப்பட்ட பொருளை விட குறைவாக உள்ளது."

"அது கொஞ்சம் வித்தியாசமானது."

"ஆம், ஆனால் நீங்கள் பொருள்களை வெறுமனே சில எண் பண்புகளின் அடிப்படையில் ஒப்பிட்டுப் பார்க்கிறீர்கள் என்றால், ஒன்றிலிருந்து மற்றொன்றைக் கழிப்பதன் மூலம் அவற்றுக்கிடையேயான வேறுபாட்டை நீங்கள் திரும்பப் பெறலாம். மேலே உள்ள எடுத்துக்காட்டில் அது எவ்வாறு செய்யப்பட்டது."

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

"நான் எல்லாவற்றையும் புரிந்துகொள்கிறேன் என்று நினைக்கிறேன். ஆனால் ஒருவேளை இல்லை. ஆனால் கிட்டத்தட்ட எல்லாமே."

"நல்லது. இப்போது இன்னும் நடைமுறைச் சிக்கலைப் பார்ப்போம். சீனாவில் பெண்களுக்கான ஆடைகளைத் தயாரிப்பதற்காக நீங்கள் ஒரு அருமையான வலைத்தளத்தை எழுதியுள்ளீர்கள் என்று வைத்துக்கொள்வோம். உங்கள் வாடிக்கையாளர்களை விவரிக்க ஒரு பெண் வகுப்பைப் பயன்படுத்துகிறீர்கள். நீங்கள் அனைவரையும் பார்க்கக்கூடிய அட்டவணையுடன் ஒரு வலைப்பக்கத்தையும் உருவாக்கியுள்ளீர்கள். ஆனால் ஒரு பிரச்சனை இருக்கிறது..."

"உங்கள் பெண் பொருளில் வயது மட்டுமல்ல, பிற தரவுகளும் உள்ளன: முதல் பெயர், கடைசி பெயர், உயரம், எடை, குழந்தைகளின் எண்ணிக்கை போன்றவை."

"பயனர்களின் அட்டவணையில் நிறைய நெடுவரிசைகள் உள்ளன, மேலும் இங்கே கேள்வி: உங்கள் பயனர்களை பல்வேறு அளவுகோல்களின்படி எவ்வாறு வரிசைப்படுத்துவது? எடை, வயது, குடும்பப்பெயர் ஆகியவற்றின் அடிப்படையில்?"

"ம்ம். ஆமாம், நான் அடிக்கடி அட்டவணைகளைப் பார்க்கிறேன், அது உங்களை நெடுவரிசை வாரியாக வரிசைப்படுத்த அனுமதிக்கும். எனவே, அதை எப்படிச் செய்வது?"

"இதற்காக, இன்று நான் உங்களுக்குச் சொல்ல விரும்பிய இரண்டாவது இடைமுகம் உள்ளது: Comparator இடைமுகம். இது ஒரு ஒப்பீட்டு முறையையும் கொண்டுள்ளது, ஆனால் அதற்கு இரண்டு வாதங்கள் தேவை, ஒன்று அல்ல: 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);

"அது ஒரு சிறந்த பாடம், பிலாபோ. மிக்க நன்றி."

"உங்களுக்கு நன்றி, என் நண்பரே!"