ஜாவா சேகரிப்புகள் வரிசை()

தரவைக் கையாளும் டெவலப்பர்களாக நமக்குத் தேவைப்படும் பொதுவான செயல்பாடுகளில் ஒன்று வரிசைப்படுத்துவது - நமது தரவை வரிசைப்படுத்துவதன் மூலம், மிக வேகமாக இயங்கும் வகையில் நமது அல்காரிதங்களை மேம்படுத்தலாம், மேலும் அதற்குத் தேவையான தரவை ஒரு குறிப்பிட்ட நேரத்திற்குள் கண்டறியலாம். இல்லையெனில் எடுக்கும். இன்றைய பாடத்தில், ஜாவா சேகரிப்புகளின் வகை() பற்றி பேசுவோம். ஒரு விரைவான சிந்தனை பரிசோதனையாக: நீங்கள் ஒரு பல்கலைக்கழகத்தின் பட்டியல் மூலம் ஒரு பெயரைத் தேடுகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். இந்த பள்ளியில் பல்லாயிரக்கணக்கான மாணவர்கள் இருக்கலாம். உங்களுக்கு வழங்கப்பட்ட பட்டியல் அகரவரிசையில் இல்லை என்றால், நீங்கள் ஒவ்வொரு பக்கத்தையும் புரட்ட வேண்டும் மற்றும் நீங்கள் தேடும் பெயரைக் கண்டுபிடிக்கும் வரை, நீங்கள் எங்கும் ஒரு பெயரைத் தவிர்க்கவில்லை என்பதை உறுதிப்படுத்த மிகவும் கவனமாகப் பார்க்க வேண்டும். மறுபுறம், பட்டியல் அகரவரிசைப்படுத்தப்பட்டிருந்தால், உங்கள் தேடலில் நீங்கள் குறைவாகவே இருக்க வேண்டும், ஆனால் அதே முதல் எழுத்துடன் பட்டியலில் உள்ள பகுதிக்கு நீங்கள் எளிதாகச் செல்லலாம், மேலும் நீங்கள் தேடும் நபரின் மீது நீங்கள் இறங்கும் வரை பெரிய பாய்ச்சல்களில் பக்கங்களைத் தொடர்ந்து குதிக்கலாம். நீங்கள் அதிக தரவுகளுடன் பணிபுரிகிறீர்கள், அதை முடிந்தவரை திறம்பட மற்றும் திறமையாகப் பயன்படுத்துகிறீர்கள் என்பது மிக முக்கியமானது. இந்த கட்டுரையில், சேகரிப்பு வரிசை முறையைப் பயன்படுத்தி ஜாவாவில் (அரேலிஸ்ட் உட்பட) எந்தப் பட்டியல் செயலாக்கத்தையும் எப்படி வரிசைப்படுத்துவது என்று பார்ப்போம்.

ஜாவா சேகரிப்பு வரிசை முறையைப் பயன்படுத்தி ஜாவாவில் வரிசைப்பட்டியலை எவ்வாறு வரிசைப்படுத்துவது

Java Collections.sort method பற்றி பேசலாம். java.util தொகுப்பில் பல பயனுள்ள பயன்பாடுகள் மற்றும் தொகுப்புகள் உள்ளன, அவை பெரும்பாலும் டெவலப்பர்களால் ArrayList உட்பட பயன்படுத்தப்படுகின்றன. உங்களிடம் பின்வரும் எளிய நிரல் உள்ளது என்று வைத்துக்கொள்வோம்:

import java.util.*;
import java.io.*;
class Main{
     public static void main(String[] args){
          List<String> colors = new ArrayList<String>();
          colors.add("Red    ");
          colors.add("Orange");
          colors.add("Green");
          colors.add("Blue");
    }
}

நீங்கள் வண்ணங்களின் பட்டியலை அச்சிட முடியும், ஆனால் அகர வரிசைப்படி. நீங்கள் இதை எப்படி செய்ய முடியும்? java.util.Collections ஐப் பயன்படுத்தி, வரிசைப்படுத்துவது ஒரு லைனரைப் போல எளிதானது:

Collections.sort(colors);

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

System.out.println(colors);

பின்னர் நீங்கள் பின்வரும் வெளியீட்டைப் பெறுவீர்கள்:

[Blue, Green, Orange, Red]

அது எவ்வளவு எளிதாக இருந்தது?! Integers, Floats அல்லது அந்த விஷயத்திற்கான வேறு ஏதேனும் எளிய தரவு வகைகளின் பட்டியலை ஏறுவரிசையில் வரிசைப்படுத்த, Collections.sort() ஐப் பயன்படுத்துவது எளிதாக இருக்கும். ஆனால் நீங்கள் இறங்கு வரிசையில் வரிசைப்படுத்த விரும்பினால் என்ன செய்வது? இது அர்த்தமுள்ளதாக இருக்கும் சந்தர்ப்பங்கள் நிச்சயமாக உள்ளன - ஒரு குறிப்பிட்ட வகுப்பிற்கான தேர்வு மதிப்பெண்களின் பட்டியலை நீங்கள் வைத்திருந்தீர்கள் என்று கற்பனை செய்து பாருங்கள், மேலும் அதிக மதிப்பெண் பெற்ற மாணவர்கள் யார் என்பதை நீங்கள் கண்டுபிடிக்க விரும்புகிறீர்கள். பட்டியலை இறங்கு வரிசையில் வரிசைப்படுத்துவது மிகவும் அர்த்தமுள்ளதாக இருக்கும் (முதலில் அதிக மதிப்பெண்கள்), நீங்கள் தேடும் பதில்கள் மேலே இருக்கும். அதிர்ஷ்டவசமாக, Collections.sort()ஒரு விருப்பமான 2வது அளவுருவுடன் மேலெழுதப்பட்டது, இது இதைச் செய்ய உங்களை அனுமதிக்கிறது:

sort(List l, Comparator c)

ஆனால் ஒப்பீட்டாளர் என்றால் என்ன? சரி, ஒப்பீட்டாளர் என்பது இரண்டு உள்ளீடுகளை ஒப்பிட்டு, எந்த உள்ளீடு முதலில் வருகிறது என்பதைக் குறிக்கும் எண்ணை வழங்கும் ஒரு செயல்பாடாகும். நீங்கள் பழமையான தரவு வகைகளின் வரிசைப்பட்டியலை வரிசைப்படுத்துகிறீர்கள் என்றால், Java Collections உங்களுக்கு ஏற்கனவே reverseOrder() comparatorஐ வழங்குகிறது. இதை இப்படி அழைக்கலாம்:

Collections.sort(colors, Collections.reverseOrder());

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

[Red, Orange, Green, Blue]

ஜாவாவில் பழமையான தரவு வகைகளை வரிசைப்படுத்த சேகரிப்புகளை எவ்வாறு பயன்படுத்துவது

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

public class Color{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(String name, int red, int green, int blue){
   	this.name = name;
    	this.r = red;
   	this.g = green;
   	this.b = blue;
	}
}

எங்கள் வண்ண வகுப்பை Collections.sort() உடன் இணங்கச் செய்வதற்கு, வண்ணப் பொருட்களை எவ்வாறு ஒப்பிடுவது மற்றும் வரிசைப்படுத்துவது என்பதை சேகரிப்புகள் புரிந்து கொள்ள, நாம் இரண்டு சிறிய மாற்றங்களைச் செய்ய வேண்டும்:

1. வண்ணத்தை ஒப்பிடக்கூடிய பொருளாக மாற்றவும் (ஒப்பிடக்கூடிய<பொருள்> கருவிகளைச் சேர்க்கவும்)
2. வகுப்பில் compareTo முறையை மேலெழுதவும் (பொது int compareTo(Object o))

இந்த மாற்றங்களுடன், எங்கள் வகுப்பு இப்போது இதுபோல் தெரிகிறது:

public class Color implements Comparable<Object>{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(int red int green, int blue, String name){
    	this.r = red;
   	this.g = green;
   	this.b = blue;
   	this.name = name;
	}

	@Override
	public int compareTo(Object o) {
    	Color c = (Color) o;
    	return this.name.compareTo(c.name);
	}
}

வண்ணத்தின் ஒப்பீட்டு முறையானது சரத்தின் ஒப்பீட்டு முறையை எளிமையாக அழைக்கிறது என்பதைக் கவனியுங்கள்; வரிசையாக்கம் அகர வரிசைப்படி செய்யப்படும். நாம் ஏறுவரிசையில் சிவப்பு மதிப்பின் மூலம் வரிசைப்படுத்த விரும்பினால், எடுத்துக்காட்டாக, ரிட்டர்ன் அறிக்கையை return this.r - cr என்று மாற்றலாம்; (பச்சை மதிப்பின்படி இறங்கு வரிசையில் வரிசைப்படுத்த விரும்பினால், அது திரும்பும் cg - this.g;). இப்போது, ​​நாம் அழைத்தால்

Collections.sort(colors);

வெறும் சரங்களை விட நிறங்களின் வரிசைப்பட்டியலில், இது வேலை செய்யும், ஏனெனில் வண்ணப் பொருட்களை எவ்வாறு ஒப்பிடுவது என்பதை சேகரிப்புகள் புரிந்துகொள்கின்றன. உங்கள் பொருளை ஒப்பிடக்கூடிய<பொருள்> செயல்படுத்த விரும்பவில்லை எனில், உங்கள் வகுப்பிற்கு ஒரு ஒப்பீட்டாளரை எழுதி, அதை 2-அளவுரு Collections.sort() முறையில் அனுப்பலாம். ஒரு ஒப்பீட்டாளர் ஒரு பொது எண்ணை ஒப்பிடும் முறையை மீறுகிறார் (பொருள் ஒன்று, பொருள் இரண்டு), மற்றும் Collections.sort() முறை வரிசைப்படுத்தும் போது பொருட்களை ஒப்பிடுவதற்கு இதைப் பயன்படுத்துகிறது. SortByName மற்றும் SortByRed ஒப்பீட்டாளர்களின் எடுத்துக்காட்டு கீழே செயல்படுத்தப்பட்டுள்ளது:

class SortByName implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.name.compareTo(b.name);
	}
}

class SortByRGB implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.r - b.r;
	}
}

இதன் மூலம், நீங்கள் இப்போது அழைக்கலாம்

Collections.sort(colors, new SortByName());

கலர் கிளாஸ் இல்லாமல் ஒப்பிடக்கூடியது செயல்படுத்தப்படுகிறது, அது இன்னும் வேலை செய்யும். சில நேரங்களில், இது லாம்ப்டா செயல்பாடுகளைப் பயன்படுத்தி இன்-லைனில் செய்யப்படுவதை நீங்கள் காண்பீர்கள். லாம்ப்டா செயல்பாடு என்பது பெயரிடப்படாத செயல்பாடாகும், அதை நீங்கள் குறியீட்டின் வரிக்குள் வரையறுக்கலாம், அதை அழைக்கிறது. நீங்கள் ஒரு குறிப்பிட்ட நிகழ்விற்கு மட்டுமே ஒரு செயல்பாட்டை அழைக்க வேண்டியிருக்கும் போது அவை பயனுள்ளதாக இருக்கும், மேலும் ஒரு முழு தனி செயல்பாட்டை வேறு எங்கும் வரையறுக்க விரும்பவில்லை. லாம்ப்டா செயல்பாட்டைப் பயன்படுத்தி, SortByName ஒப்பீட்டாளரை வரியில் வரையறுக்கலாம், இது போன்றது:

Collections.sort(colors, (a, b)-> {
          return a.name.compareTo(b.name)});

நீங்கள் யூகித்தபடி, (a, b) என்பது லாம்ப்டா செயல்பாடுகளின் அளவுருக்களைக் குறிக்கிறது (ஒப்பிட வேண்டிய இரண்டு பொருள்கள்). பின்வருபவை ஒரு லாம்ப்டா செயல்பாடு வரையறை என்பதை -> குறிக்கிறது. அது பற்றி! சேகரிப்புகள் தொகுப்பைப் பயன்படுத்தி ஜாவாவில் ArrayLists வரிசைப்படுத்தும் மிகவும் பிரபலமான முறைகளை நீங்கள் இப்போது பார்த்திருக்கிறீர்கள்.